package edu.server.servicio;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

import com.google.gwt.user.server.rpc.RemoteServiceServlet;

import edu.client.Validaciones;
import edu.client.IngenieriaService.IngenieriaService;
import edu.server.dominio.D_ClaseProducto;
import edu.server.dominio.D_ElementoProducto;
import edu.server.dominio.D_Empleado;
import edu.server.dominio.D_Inventario;
import edu.server.dominio.D_MaterialProducto;
import edu.server.dominio.D_MedidaFijaProducto;
import edu.server.dominio.D_MedidaVariableEstandarProducto;
import edu.server.dominio.D_OrdenFabricacionGeneral;
import edu.server.dominio.D_OrdenPedido;
import edu.server.dominio.D_Producto;
import edu.server.dominio.D_Proveedor;
import edu.server.dominio.D_ProveedorDeProducto;
import edu.server.dominio.Ingenieria;
import edu.server.repositorio.ClaseEquipoPatron;
import edu.server.repositorio.ClaseProducto;
import edu.server.repositorio.ComponentePatron;
import edu.server.repositorio.Contacto;
import edu.server.repositorio.ElementoProducto;
import edu.server.repositorio.ElementoProductoId;
import edu.server.repositorio.Empleado;
import edu.server.repositorio.EquipoPatron;
import edu.server.repositorio.Inventario;
import edu.server.repositorio.ListaDeMateriales;
import edu.server.repositorio.MaterialProducto;
import edu.server.repositorio.MedidaFijaProducto;
import edu.server.repositorio.MedidasVariablesEstandar;
import edu.server.repositorio.MedidasVariablesEstandarId;
import edu.server.repositorio.OrdenFabricacionGeneral;
import edu.server.repositorio.OrdenPedido;
import edu.server.repositorio.Producto;
import edu.server.repositorio.Proveedor;
import edu.server.repositorio.ProveedorDeProducto;
import edu.server.repositorio.ProveedorDeProductoId;
import edu.server.repositorio.RenglonListaMateriales;
import edu.server.repositorio.RenglonListaMaterialesId;
import edu.server.repositorio.RenglonOrdenFabricacionGeneral;
import edu.server.repositorio.RenglonOrdenFabricacionGeneralId;
import edu.server.repositorio.RenglonOrdenPedido;
import edu.server.repositorio.RenglonOrdenPedidoId;
import edu.server.repositorio.SubclaseEquipoPatron;
import edu.server.repositorio.SubclaseEquipoPatronId;
import edu.shared.DTO.ClaseEquipoPatronDTO;
import edu.shared.DTO.ClaseProductoDTO;
import edu.shared.DTO.ComponentePatronDTO;
import edu.shared.DTO.ContactoDTO;
import edu.shared.DTO.DireccionDTO;
import edu.shared.DTO.ElementoProductoDTO;
import edu.shared.DTO.EquipoPatronDTO;
import edu.shared.DTO.ListaDeMaterialesDTO;
import edu.shared.DTO.MaterialProductoDTO;
import edu.shared.DTO.MedidaFijaProductoDTO;
import edu.shared.DTO.MedidaVariableEstandarDTO;
import edu.shared.DTO.OrdenFabricacionGeneralDTO;
import edu.shared.DTO.OrdenPedidoDTO;
import edu.shared.DTO.ProductoDTO;
import edu.shared.DTO.ProveedorDTO;
import edu.shared.DTO.RenglonListaMaterialesDTO;
import edu.shared.DTO.RenglonOrdenFabricacionGeneralDTO;
import edu.shared.DTO.RenglonOrdenPedidoDTO;
import edu.shared.DTO.SubclaseEquipoPatronDTO;
//import edu.server.dominio.D_Proveedor;

public class IngenieriaServiceImpl extends RemoteServiceServlet implements IngenieriaService {

	/**
	 * 
	 */
	private static final long serialVersionUID = -1913772067496992456L;

	/**
	 * Método que busca todas las clases de equipo patrón existentes.
	 */
	public List<ClaseEquipoPatronDTO> buscarClasesEquipoPatron() throws IllegalArgumentException {
		
		List<ClaseEquipoPatron> listaClasesEquipoPatron = new LinkedList<ClaseEquipoPatron>();
		List<ClaseEquipoPatronDTO> listaClasesEquipoPatronDTO = new LinkedList<ClaseEquipoPatronDTO>();
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		listaClasesEquipoPatron = adminIngenieria.buscarClasesEquipoPatron();
		
		for(ClaseEquipoPatron claseEquipoPatron: listaClasesEquipoPatron){
			
			ClaseEquipoPatronDTO nuevaClaseEquipoPatronDTO = new ClaseEquipoPatronDTO();
			nuevaClaseEquipoPatronDTO.setCodigoClaseEquipoPatron(claseEquipoPatron.getCodigoClaseEquipoPatron());
			nuevaClaseEquipoPatronDTO.setNombre(claseEquipoPatron.getNombre());
			
			listaClasesEquipoPatronDTO.add(nuevaClaseEquipoPatronDTO);			
		}
		
		return listaClasesEquipoPatronDTO;
	}

	/**
	 * Método que busca todas las subclases de equipo patrón existentes para una clase dada.
	 */
	public List<SubclaseEquipoPatronDTO> buscarSubclasesEquipoPatron(int codigoClaseEquipoPatron) throws IllegalArgumentException  {

		List<SubclaseEquipoPatron> listaSubclasesEquipoPatron = new LinkedList<SubclaseEquipoPatron>();
		List<SubclaseEquipoPatronDTO> listaSubclasesEquipoPatronDTO = new LinkedList<SubclaseEquipoPatronDTO>();
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		listaSubclasesEquipoPatron = adminIngenieria.buscarSubclasesEquipoPatron(codigoClaseEquipoPatron);
		
		for(SubclaseEquipoPatron subclaseEquipoPatron: listaSubclasesEquipoPatron) {
			
			SubclaseEquipoPatronDTO subclaseEquipoPatronDTO = new SubclaseEquipoPatronDTO();
			subclaseEquipoPatronDTO.setCodigoSubclase(subclaseEquipoPatron.getId().getCodigoSubclaseEquipoPatron());
			subclaseEquipoPatronDTO.setNombre(subclaseEquipoPatron.getNombre());
			
			listaSubclasesEquipoPatronDTO.add(subclaseEquipoPatronDTO);
		}

		return listaSubclasesEquipoPatronDTO;
	}
	
	/**
	 * Método que busca todos los equipos patrón existentes para una clase y subclase dada. Se retornarán todos
	 * los planos de un equipo particular en su última versión.
	 */
	public List<EquipoPatronDTO> buscarPlanosEquipoPatron(int codigoClaseEquipoPatron, int codigoSubclaseEquipoPatron) throws IllegalArgumentException {

		List<EquipoPatron> listaEquiposPatron = new LinkedList<EquipoPatron>();
		List<EquipoPatronDTO> listaEquiposPatronDTO = new LinkedList<EquipoPatronDTO>();
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		listaEquiposPatron = adminIngenieria.buscarPlanosEquipoPatron(codigoClaseEquipoPatron, codigoSubclaseEquipoPatron);
		
		for(EquipoPatron equipoPatron: listaEquiposPatron) {
			
			EquipoPatronDTO equipoPatronDTO = new EquipoPatronDTO();
			
			equipoPatronDTO.setCodigoClase(equipoPatron.getSubclaseEquipoPatron().getId().getCodigoClaseEquipoPatron());
			equipoPatronDTO.setNombreClase(equipoPatron.getSubclaseEquipoPatron().getClaseEquipoPatron().getNombre());
			equipoPatronDTO.setCodigoSubclase(equipoPatron.getSubclaseEquipoPatron().getId().getCodigoSubclaseEquipoPatron());
			equipoPatronDTO.setNombreSubclase(equipoPatron.getSubclaseEquipoPatron().getNombre());
			equipoPatronDTO.setPlano(equipoPatron.getPlano());
			equipoPatronDTO.setNroVersion(equipoPatron.getNroVersion());
			equipoPatronDTO.setDescripcionTecnica(equipoPatron.getDescripcionTecnica());
			
			listaEquiposPatronDTO.add(equipoPatronDTO);
		}

		return listaEquiposPatronDTO;
	}
	
	/**
	 * Método que busca todos los equipos patrones existentes en la base de datos.
	 */
	@Override
	public List<EquipoPatronDTO> buscarEquiposPatron() throws IllegalArgumentException {

		List<EquipoPatron> listaEquiposPatron = new LinkedList<EquipoPatron>();
		List<EquipoPatronDTO> listaEquiposPatronDTO = new LinkedList<EquipoPatronDTO>();
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		listaEquiposPatron = adminIngenieria.buscarEquiposPatron();
		
		for(EquipoPatron equipoPatron: listaEquiposPatron) {
			
			EquipoPatronDTO equipoPatronDTO = new EquipoPatronDTO();
			
			equipoPatronDTO.setCodigoClase(equipoPatron.getSubclaseEquipoPatron().getId().getCodigoClaseEquipoPatron());
			equipoPatronDTO.setNombreClase(equipoPatron.getSubclaseEquipoPatron().getClaseEquipoPatron().getNombre());
			equipoPatronDTO.setCodigoSubclase(equipoPatron.getSubclaseEquipoPatron().getId().getCodigoSubclaseEquipoPatron());
			equipoPatronDTO.setNombreSubclase(equipoPatron.getSubclaseEquipoPatron().getNombre());
			equipoPatronDTO.setPlano(equipoPatron.getPlano());
			equipoPatronDTO.setNroVersion(equipoPatron.getNroVersion());
			equipoPatronDTO.setCantidadDisponible(equipoPatron.getCantidadDisponible());
			equipoPatronDTO.setDescripcionTecnica(equipoPatron.getDescripcionTecnica());
			
			listaEquiposPatronDTO.add(equipoPatronDTO);
		}

		return listaEquiposPatronDTO;
	}
	
	/**
	 * Método que busca todos los equipos patrones que existen en almacén. Tener en cuenta que los equipos buscados en esta función
	 * pueden estar activos o no.
	 */
	@Override
	public List<EquipoPatronDTO> buscarEquiposPatronEnAlmacen() throws IllegalArgumentException {

		List<EquipoPatron> listaEquiposPatron = new LinkedList<EquipoPatron>();
		List<EquipoPatronDTO> listaEquiposPatronDTO = new LinkedList<EquipoPatronDTO>();
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		listaEquiposPatron = adminIngenieria.buscarEquiposPatronEnAlmacen();
		
		for(EquipoPatron equipoPatron: listaEquiposPatron) {
			
			EquipoPatronDTO equipoPatronDTO = new EquipoPatronDTO();
			
			equipoPatronDTO.setCodigoClase(equipoPatron.getSubclaseEquipoPatron().getId().getCodigoClaseEquipoPatron());
			equipoPatronDTO.setNombreClase(equipoPatron.getSubclaseEquipoPatron().getClaseEquipoPatron().getNombre());
			equipoPatronDTO.setCodigoSubclase(equipoPatron.getSubclaseEquipoPatron().getId().getCodigoSubclaseEquipoPatron());
			equipoPatronDTO.setNombreSubclase(equipoPatron.getSubclaseEquipoPatron().getNombre());
			equipoPatronDTO.setPlano(equipoPatron.getPlano());
			equipoPatronDTO.setNroVersion(equipoPatron.getNroVersion());
			equipoPatronDTO.setCantidadDisponible(equipoPatron.getCantidadDisponible());
			equipoPatronDTO.setDescripcionTecnica(equipoPatron.getDescripcionTecnica());
			
			listaEquiposPatronDTO.add(equipoPatronDTO);
		}

		return listaEquiposPatronDTO;
	}
	
	@Override
	public List<EquipoPatronDTO> buscarEquiposPatronUltimaVersion(int codigoClase, int codigoSubclase) throws IllegalArgumentException {

		List<EquipoPatron> listaEquiposPatron = new LinkedList<EquipoPatron>();
		List<EquipoPatronDTO> listaEquiposPatronDTO = new LinkedList<EquipoPatronDTO>();
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		// si codigoClase = -1, se buscan todos los equipos patrón en su última versión.
		if (codigoClase == -1) {
			listaEquiposPatron = adminIngenieria.buscarEquiposPatronUltimaVersion();
		}
		
		// si codigoSubclase = -1, se buscan todos los equipos patrón con el código de clase especificado (todas sus subclases), en su última versión.
		else if (codigoSubclase == -1) {
			listaEquiposPatron = adminIngenieria.buscarEquiposPatronUltimaVersion(codigoClase);
		}
		
		// si codigoClase != -1 y codigoSubclase != -1, se buscan los equipos patrón especificados (todos los planos), en su última versión.
		else {
			listaEquiposPatron = adminIngenieria.buscarPlanosEquipoPatron(codigoClase, codigoSubclase);
		}
		
		for(EquipoPatron equipoPatron: listaEquiposPatron) {
			
			EquipoPatronDTO equipoPatronDTO = new EquipoPatronDTO();
			
			equipoPatronDTO.setCodigoClase(equipoPatron.getSubclaseEquipoPatron().getId().getCodigoClaseEquipoPatron());
			equipoPatronDTO.setNombreClase(equipoPatron.getSubclaseEquipoPatron().getClaseEquipoPatron().getNombre());
			equipoPatronDTO.setCodigoSubclase(equipoPatron.getSubclaseEquipoPatron().getId().getCodigoSubclaseEquipoPatron());
			equipoPatronDTO.setNombreSubclase(equipoPatron.getSubclaseEquipoPatron().getNombre());
			equipoPatronDTO.setPlano(equipoPatron.getPlano());
			equipoPatronDTO.setNroVersion(equipoPatron.getNroVersion());
			equipoPatronDTO.setCantidadDisponible(equipoPatron.getCantidadDisponible());
			equipoPatronDTO.setDescripcionTecnica(equipoPatron.getDescripcionTecnica());
			equipoPatronDTO.setActivo(equipoPatron.isActivo());
			equipoPatronDTO.setIdListaDeMateriales(equipoPatron.getListaDeMateriales().getIdListaMateriales());
			equipoPatronDTO.setEstadoListaMateriales(adminIngenieria.buscarEstadoListaMateriales(equipoPatronDTO.getIdListaDeMateriales()));
			
			listaEquiposPatronDTO.add(equipoPatronDTO);
		}

		return listaEquiposPatronDTO;	
	}	
	
	/**
	 * Función utilizada para buscar un componente patron particular.
	 */
	@Override
	public ComponentePatronDTO buscarComponentePatron(int codigoClase, int codigoSubclase, String version, int codigoComponente, int codigoSubcomponente, int plano) throws IllegalArgumentException {

		ComponentePatron componentePatron = new ComponentePatron();
		ComponentePatronDTO componentePatronDTO = new ComponentePatronDTO();
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		componentePatron = adminIngenieria.buscarComponentePatron(codigoClase, codigoSubclase, version, codigoComponente, codigoSubcomponente, plano);
		
		componentePatronDTO.setCodigoClase(componentePatron.getSubclaseEquipoPatron().getId().getCodigoClaseEquipoPatron());
		componentePatronDTO.setCodigoSubclase(componentePatron.getSubclaseEquipoPatron().getId().getCodigoSubclaseEquipoPatron());
		componentePatronDTO.setNombreClase(componentePatron.getSubclaseEquipoPatron().getClaseEquipoPatron().getNombre());
		componentePatronDTO.setNombreSubclase(componentePatron.getSubclaseEquipoPatron().getNombre());
		componentePatronDTO.setNombre(componentePatron.getNombre());
		componentePatronDTO.setCodigoComponente(componentePatron.getCodigoComponente());
		componentePatronDTO.setCodigoSubcomponente(componentePatron.getCodigoSubcomponente());
		componentePatronDTO.setPlano(componentePatron.getPlano());
		componentePatronDTO.setNroVersion(componentePatron.getNroVersion());
		componentePatronDTO.setCantidadDisponible(componentePatron.getCantidadDisponible());
		componentePatronDTO.setDescripcionTecnica(componentePatron.getDescripcionTecnica());
		componentePatronDTO.setActivo(componentePatron.isActivo());
		componentePatronDTO.setIdListaMateriales(componentePatron.getListaDeMateriales().getIdListaMateriales());
		//componentePatronDTO.setEstadoListaMateriales(adminIngenieria.buscarEstadoListaMateriales(componentePatronDTO.getIdListaMateriales()));
		componentePatronDTO.setEstadoListaMateriales(componentePatron.getListaDeMateriales().getEstado());

		return componentePatronDTO;	
	}
	
	
	/**
	 * Método que registra la lista de materiales pasada como parámetro.
	 * @return un int que es el identificador de la lista de materiales.
	 */
	public int registrarListaMateriales(ListaDeMaterialesDTO listaDeMaterialesDTO) throws IllegalArgumentException {

		ListaDeMateriales listaDeMateriales = new ListaDeMateriales();
		
		int idListaMateriales;
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		listaDeMateriales.setIdListaMateriales(listaDeMaterialesDTO.getIdListaMateriales());
		listaDeMateriales.setEstado(listaDeMaterialesDTO.getEstado());
		
		Set<RenglonListaMateriales> rengloneslistaMateriales = new HashSet<RenglonListaMateriales>();
		
		for (RenglonListaMaterialesDTO renglonDTO : listaDeMaterialesDTO.getRenglonListaMaterialesesDTO()) {
			RenglonListaMateriales renglon = new RenglonListaMateriales();
						
			renglon.setCantidad(renglonDTO.getCantidad());
			
			if (renglonDTO.getTipoRenglon().equals("EQUIPO")) {
			
				int codigoClase = renglonDTO.getEquipoPatronDTO().getCodigoClase();
				int codigoSubclase = renglonDTO.getEquipoPatronDTO().getCodigoSubclase();
				String version = renglonDTO.getEquipoPatronDTO().getNroVersion();
				int plano = renglonDTO.getEquipoPatronDTO().getPlano();
			
				EquipoPatron equipoPatron = adminIngenieria.buscarEquipoPatron(codigoClase, codigoSubclase, plano, version);
				renglon.setEquipoPatron(equipoPatron);				
			}
			
			else if (renglonDTO.getTipoRenglon().equals("COMPONENTE")) {
				
				int codigoClase = renglonDTO.getComponentePatronDTO().getCodigoClase();
				int codigoSubclase = renglonDTO.getComponentePatronDTO().getCodigoSubclase();
				String version = renglonDTO.getComponentePatronDTO().getNroVersion();
				int codigoComponente = renglonDTO.getComponentePatronDTO().getCodigoComponente();
				int codigoSubcomponente = renglonDTO.getComponentePatronDTO().getCodigoSubcomponente();
				int plano = renglonDTO.getComponentePatronDTO().getPlano();
				
				ComponentePatron componentePatron = adminIngenieria.buscarComponentePatron(codigoClase, codigoSubclase, version, codigoComponente, codigoSubcomponente, plano);
				renglon.setComponentePatron(componentePatron);
			}
			
			else {
				
				D_Producto adminProducto = new D_Producto();
				
				Producto producto = adminProducto.buscarProducto(renglonDTO.getProductoDTO().getIdProducto());
				renglon.setMedida1(renglonDTO.getMedida1());
				renglon.setMedida2(renglonDTO.getMedida2());
				renglon.setProducto(producto);
			}
			
			rengloneslistaMateriales.add(renglon);
		}
		
		listaDeMateriales.setRenglonListaMaterialeses(rengloneslistaMateriales);
		
		idListaMateriales = adminIngenieria.registrarListaMateriales(listaDeMateriales);
		
		return idListaMateriales;
	}
	
	/**
	 * Función utilizada para buscar un equipo patron particular con toda su lista de materiales inicializada.
	 */
	@Override
	public ListaDeMaterialesDTO buscarListaMateriales(int idListaMateriales) throws IllegalArgumentException {

		ListaDeMaterialesDTO listaDeMaterialesDTO = new ListaDeMaterialesDTO();
		ListaDeMateriales listaDeMateriales = new ListaDeMateriales();
		LinkedList<RenglonListaMaterialesDTO> renglonesListaMaterialesDTO = new LinkedList<RenglonListaMaterialesDTO>();
				
		Ingenieria adminIngenieria = new Ingenieria();
		
		listaDeMateriales = adminIngenieria.buscarListaDeMateriales(idListaMateriales);
		
		listaDeMaterialesDTO.setIdListaMateriales(listaDeMateriales.getIdListaMateriales());
		listaDeMaterialesDTO.setEstado(listaDeMateriales.getEstado());
		
		for (RenglonListaMateriales renglon : listaDeMateriales.getRenglonListaMaterialeses()) {
			
			RenglonListaMaterialesDTO renglonDTO = new RenglonListaMaterialesDTO();
			
			if (renglon.getEquipoPatron() != null) {
				EquipoPatronDTO equipoPatronRenglonDTO = new EquipoPatronDTO();
				
				equipoPatronRenglonDTO.setCodigoClase(renglon.getEquipoPatron().getSubclaseEquipoPatron().getId().getCodigoClaseEquipoPatron());
				equipoPatronRenglonDTO.setNombreClase(renglon.getEquipoPatron().getSubclaseEquipoPatron().getClaseEquipoPatron().getNombre());
				equipoPatronRenglonDTO.setCodigoSubclase(renglon.getEquipoPatron().getSubclaseEquipoPatron().getId().getCodigoSubclaseEquipoPatron());
				equipoPatronRenglonDTO.setNombreSubclase(renglon.getEquipoPatron().getSubclaseEquipoPatron().getNombre());
				equipoPatronRenglonDTO.setPlano(renglon.getEquipoPatron().getPlano());
				equipoPatronRenglonDTO.setNroVersion(renglon.getEquipoPatron().getNroVersion());
				equipoPatronRenglonDTO.setCantidadDisponible(renglon.getEquipoPatron().getCantidadDisponible());
				equipoPatronRenglonDTO.setDescripcionTecnica(renglon.getEquipoPatron().getDescripcionTecnica());
				equipoPatronRenglonDTO.setActivo(renglon.getEquipoPatron().isActivo());
				equipoPatronRenglonDTO.setEstadoListaMateriales(renglon.getEquipoPatron().getListaDeMateriales().getEstado());
				
				renglonDTO.setIdListaMateriales(renglon.getEquipoPatron().getListaDeMateriales().getIdListaMateriales());
				renglonDTO.setEquipoPatronDTO(equipoPatronRenglonDTO);				
				renglonDTO.setTipoRenglon("EQUIPO");
			}
			else if (renglon.getComponentePatron() != null) {
				ComponentePatronDTO componentePatronRenglonDTO = new ComponentePatronDTO();
				
				componentePatronRenglonDTO.setCodigoClase(renglon.getComponentePatron().getSubclaseEquipoPatron().getId().getCodigoClaseEquipoPatron());
				componentePatronRenglonDTO.setCodigoSubclase(renglon.getComponentePatron().getSubclaseEquipoPatron().getId().getCodigoSubclaseEquipoPatron());
				componentePatronRenglonDTO.setNombreClase(renglon.getComponentePatron().getSubclaseEquipoPatron().getClaseEquipoPatron().getNombre());
				componentePatronRenglonDTO.setNombreSubclase(renglon.getComponentePatron().getSubclaseEquipoPatron().getNombre());
				componentePatronRenglonDTO.setNombre(renglon.getComponentePatron().getNombre());
				componentePatronRenglonDTO.setCodigoComponente(renglon.getComponentePatron().getCodigoComponente());
				componentePatronRenglonDTO.setCodigoSubcomponente(renglon.getComponentePatron().getCodigoSubcomponente());
				componentePatronRenglonDTO.setPlano(renglon.getComponentePatron().getPlano());
				componentePatronRenglonDTO.setNroVersion(renglon.getComponentePatron().getNroVersion());
				componentePatronRenglonDTO.setCantidadDisponible(renglon.getComponentePatron().getCantidadDisponible());
				componentePatronRenglonDTO.setDescripcionTecnica(renglon.getComponentePatron().getDescripcionTecnica());
				componentePatronRenglonDTO.setActivo(renglon.getComponentePatron().isActivo());
				componentePatronRenglonDTO.setEstadoListaMateriales(renglon.getComponentePatron().getListaDeMateriales().getEstado());
				
				renglonDTO.setIdListaMateriales(renglon.getComponentePatron().getListaDeMateriales().getIdListaMateriales());
				renglonDTO.setComponentePatronDTO(componentePatronRenglonDTO);
				renglonDTO.setTipoRenglon("COMPONENTE");
			}
			
			else {
				ProductoDTO productoRenglonDTO = new ProductoDTO();
				ClaseProductoDTO claseDTO = new ClaseProductoDTO();
				ElementoProductoDTO elementoDTO = new ElementoProductoDTO();
				MedidaFijaProductoDTO medidaDTO = new MedidaFijaProductoDTO();
				MaterialProductoDTO materialDTO = new MaterialProductoDTO();				
				
				claseDTO.setCodigo(renglon.getProducto().getElementoProducto().getId().getCodigoClaseProducto());
				claseDTO.setNombre(renglon.getProducto().getElementoProducto().getClaseProducto().getNombre());
				elementoDTO.setClase(claseDTO);
				elementoDTO.setCodigo(renglon.getProducto().getElementoProducto().getId().getCodigoElementoProducto());
				elementoDTO.setNombre(renglon.getProducto().getElementoProducto().getNombre());
				elementoDTO.setTipoDimension(renglon.getProducto().getElementoProducto().getTipoDimension());
				medidaDTO.setCodigo(renglon.getProducto().getMedidaFijaProducto().getCodigoMedidaFijaProducto());
				medidaDTO.setMedida(renglon.getProducto().getMedidaFijaProducto().getMedida());
				materialDTO.setCodigo(renglon.getProducto().getMaterialProducto().getCodigoMaterialProducto());
				materialDTO.setNombre(renglon.getProducto().getMaterialProducto().getNombre());
				productoRenglonDTO.setIdProducto(renglon.getProducto().getIdProducto());
				productoRenglonDTO.setElemento(elementoDTO);
				productoRenglonDTO.setMedidaFija(medidaDTO);
				productoRenglonDTO.setMaterial(materialDTO);
				productoRenglonDTO.setActivo(renglon.getProducto().isActivo());
				
				renglonDTO.setMedida1(renglon.getMedida1());
				
				if(elementoDTO.getTipoDimension().equals("SUPERFICIE"))
					renglonDTO.setMedida2(renglon.getMedida2());
				
				renglonDTO.setProductoDTO(productoRenglonDTO);
				renglonDTO.setTipoRenglon("PRODUCTO");
			}
			
			renglonDTO.setCantidad(renglon.getCantidad());
			
			renglonesListaMaterialesDTO.add(renglonDTO);
		}
		
		listaDeMaterialesDTO.setRenglonListaMaterialesesDTO(renglonesListaMaterialesDTO);
		
		return listaDeMaterialesDTO;
	}
		
	/**
	 * Busca todos los componentes patrón detallados en los parámetros, activos e inactivos, en su última versión
	 */
	@Override
	public List<ComponentePatronDTO> buscarComponentesPatronUltimaVersion(int codigoClase, int codigoSubclase, int codigoComponente, int codigoSubcomponente) throws IllegalArgumentException {

		List<ComponentePatron> listaComponentesPatron = new LinkedList<ComponentePatron>();
		List<ComponentePatronDTO> listaComponentesPatronDTO = new LinkedList<ComponentePatronDTO>();
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		// si codigoClase = -1, se buscan todos los componentes patrón en su última versión, activos e inactivos.
		if (codigoClase == -1) {
			listaComponentesPatron = adminIngenieria.buscarComponentesPatronUltimaVersion();
		}
		
		// si codigoSubclase = -1, se buscan todos los componentes patrón con el código de clase especificado (todas sus subclases), en su última versión, activos e inactivos.
		else if (codigoSubclase == -1) {
			listaComponentesPatron = adminIngenieria.buscarComponentesPatronUltimaVersion(codigoClase);
		}
		
		// si codigoSubclase =! -1 y codigoClase =! -1 se buscan todos los componentes patrón con el código de clase y subclase especificado, en su última versión, activos e inactivos.
		else if (codigoComponente == -1) {
			listaComponentesPatron = adminIngenieria.buscarComponentesPatronUltimaVersion(codigoClase, codigoSubclase);
		}
		
		// si codigoClase != -1, codigoSubclase != -1 y codigoComponente =! -1, se buscan los componentes y subcomponentes patrón especificados, en su última versión, activos e inactivos.
		else if (codigoSubcomponente == -1){
			listaComponentesPatron = adminIngenieria.buscarComponentesPatronUltimaVersion(codigoClase, codigoSubclase, codigoComponente);
		}
		
		// si codigoClase != -1, codigoSubclase != -1, codigoComponente =! -1 y codigoSubcomponente != -1, se buscan todos los planos del subcomponente especificado, en su última versión, activos e inactivos. 
		else {
			listaComponentesPatron = adminIngenieria.buscarComponentesPatronUltimaVersion(codigoClase, codigoSubclase, codigoComponente, codigoSubcomponente);
		}
		
		for(ComponentePatron componentePatron: listaComponentesPatron) {
			
			ComponentePatronDTO componentePatronDTO = new ComponentePatronDTO();
			
			componentePatronDTO.setCodigoClase(componentePatron.getSubclaseEquipoPatron().getId().getCodigoClaseEquipoPatron());
			componentePatronDTO.setCodigoSubclase(componentePatron.getSubclaseEquipoPatron().getId().getCodigoSubclaseEquipoPatron());
			componentePatronDTO.setNombreClase(componentePatron.getSubclaseEquipoPatron().getClaseEquipoPatron().getNombre());
			componentePatronDTO.setNombreSubclase(componentePatron.getSubclaseEquipoPatron().getNombre());
			componentePatronDTO.setNombre(componentePatron.getNombre());
			componentePatronDTO.setCodigoComponente(componentePatron.getCodigoComponente());
			componentePatronDTO.setCodigoSubcomponente(componentePatron.getCodigoSubcomponente());
			componentePatronDTO.setPlano(componentePatron.getPlano());
			componentePatronDTO.setNroVersion(componentePatron.getNroVersion());
			componentePatronDTO.setCantidadDisponible(componentePatron.getCantidadDisponible());
			componentePatronDTO.setDescripcionTecnica(componentePatron.getDescripcionTecnica());
			componentePatronDTO.setActivo(componentePatron.isActivo());
			componentePatronDTO.setIdListaMateriales(componentePatron.getListaDeMateriales().getIdListaMateriales());
			componentePatronDTO.setEstadoListaMateriales(adminIngenieria.buscarEstadoListaMateriales(componentePatronDTO.getIdListaMateriales()));
			
			listaComponentesPatronDTO.add(componentePatronDTO);
		}

		return listaComponentesPatronDTO;	
	}
	
	
	/**
	 * Método que busca todos los componentes patrón existentes para una clase y subclase dada, que tengan distinto código de componente y subcomponente.
	 */
	public List<ComponentePatronDTO> buscarComponentesPatron(int codigoClaseEquipoPatron, int codigoSubclaseEquipoPatron) throws IllegalArgumentException {

		List<ComponentePatron> listaComponentesPatron = new LinkedList<ComponentePatron>();
		List<ComponentePatronDTO> listaComponentesPatronDTO = new LinkedList<ComponentePatronDTO>();
		int codigoComponenteAnterior = -1;
		int codigoSubcomponenteAnterior = -1;
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		listaComponentesPatron = adminIngenieria.buscarComponentesPatron(codigoClaseEquipoPatron, codigoSubclaseEquipoPatron);
		
		for(ComponentePatron componentePatron: listaComponentesPatron) {
			
			//Pregunto si el código del componente es igual al del anterior, en cuyo caso no me interesa.
			if ((codigoComponenteAnterior != componentePatron.getCodigoComponente()) || 
					(codigoSubcomponenteAnterior != componentePatron.getCodigoSubcomponente())) {
				
				ComponentePatronDTO componentePatronDTO = new ComponentePatronDTO();
				
				componentePatronDTO.setCodigoClase(componentePatron.getSubclaseEquipoPatron().getId().getCodigoClaseEquipoPatron());
				componentePatronDTO.setCodigoSubclase(componentePatron.getSubclaseEquipoPatron().getId().getCodigoSubclaseEquipoPatron());
				componentePatronDTO.setCodigoComponente(componentePatron.getCodigoComponente());
				componentePatronDTO.setCodigoSubcomponente(componentePatron.getCodigoSubcomponente());
				componentePatronDTO.setNombre(componentePatron.getNombre());
				componentePatronDTO.setIdListaMateriales(componentePatron.getListaDeMateriales().getIdListaMateriales());
				
				listaComponentesPatronDTO.add(componentePatronDTO);
				
				codigoComponenteAnterior = componentePatron.getCodigoComponente();
				codigoSubcomponenteAnterior = componentePatron.getCodigoSubcomponente();
			}
		}

		return listaComponentesPatronDTO;
	}
	
	@Override
	public List<ComponentePatronDTO> buscarComponentesPatronUltimaVersionActivos() throws IllegalArgumentException {

		List<ComponentePatron> listaComponentesPatron = new LinkedList<ComponentePatron>();
		List<ComponentePatronDTO> listaComponentesPatronDTO = new LinkedList<ComponentePatronDTO>();
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		listaComponentesPatron = adminIngenieria.buscarComponentesPatronUltimaVersionActivos();
		
		for(ComponentePatron componentePatron: listaComponentesPatron) {
			
			ComponentePatronDTO componentePatronDTO = new ComponentePatronDTO();
			
			componentePatronDTO.setCodigoClase(componentePatron.getSubclaseEquipoPatron().getId().getCodigoClaseEquipoPatron());
			componentePatronDTO.setCodigoSubclase(componentePatron.getSubclaseEquipoPatron().getId().getCodigoSubclaseEquipoPatron());
			componentePatronDTO.setNombreClase(componentePatron.getSubclaseEquipoPatron().getClaseEquipoPatron().getNombre());
			componentePatronDTO.setNombreSubclase(componentePatron.getSubclaseEquipoPatron().getNombre());
			componentePatronDTO.setNombre(componentePatron.getNombre());
			componentePatronDTO.setCodigoComponente(componentePatron.getCodigoComponente());
			componentePatronDTO.setCodigoSubcomponente(componentePatron.getCodigoSubcomponente());
			componentePatronDTO.setPlano(componentePatron.getPlano());
			componentePatronDTO.setNroVersion(componentePatron.getNroVersion());
			componentePatronDTO.setCantidadDisponible(componentePatron.getCantidadDisponible());
			componentePatronDTO.setDescripcionTecnica(componentePatron.getDescripcionTecnica());
			componentePatronDTO.setActivo(componentePatron.isActivo());
			componentePatronDTO.setIdListaMateriales(componentePatron.getListaDeMateriales().getIdListaMateriales());
			componentePatronDTO.setEstadoListaMateriales(adminIngenieria.buscarEstadoListaMateriales(componentePatronDTO.getIdListaMateriales()));
			
			listaComponentesPatronDTO.add(componentePatronDTO);
		}

		return listaComponentesPatronDTO;	
	}
	
	/**
	 * Método que busca todos los componentes patrón existentes para una clase y subclase dada. Se retornarán todos
	 * los planos de un componente particular en su última versión.
	 */
	public List<ComponentePatronDTO> buscarPlanosComponentePatron(int codigoClase, int codigoSubclase, int codigoComponente, int codigoSubcomponente) throws IllegalArgumentException {

		List<ComponentePatron> listaComponentesPatron = new LinkedList<ComponentePatron>();
		List<ComponentePatronDTO> listaComponentesPatronDTO = new LinkedList<ComponentePatronDTO>();
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		listaComponentesPatron = adminIngenieria.buscarPlanosComponentePatron(codigoClase, codigoSubclase, codigoComponente, codigoSubcomponente);
		
		for(ComponentePatron componentePatron: listaComponentesPatron) {
			
			ComponentePatronDTO componentePatronDTO = new ComponentePatronDTO();

			componentePatronDTO.setCodigoClase(componentePatron.getSubclaseEquipoPatron().getId().getCodigoClaseEquipoPatron());
			componentePatronDTO.setNombreClase(componentePatron.getSubclaseEquipoPatron().getClaseEquipoPatron().getNombre());
			componentePatronDTO.setCodigoSubclase(componentePatron.getSubclaseEquipoPatron().getId().getCodigoSubclaseEquipoPatron());
			componentePatronDTO.setNombreSubclase(componentePatron.getSubclaseEquipoPatron().getNombre());
			componentePatronDTO.setCodigoComponente(componentePatron.getCodigoComponente());
			componentePatronDTO.setCodigoSubcomponente(componentePatron.getCodigoSubcomponente());
			componentePatronDTO.setNombre(componentePatron.getNombre());
			componentePatronDTO.setPlano(componentePatron.getPlano());
			componentePatronDTO.setNroVersion(componentePatron.getNroVersion());
			componentePatronDTO.setDescripcionTecnica(componentePatron.getDescripcionTecnica());
			componentePatronDTO.setIdComponentePatron(componentePatron.getIdComponentePatron());
			componentePatronDTO.setLote(componentePatron.getLote());
			componentePatronDTO.setPuntoPedido(componentePatron.getPuntoPedido());
			componentePatronDTO.setEstadoListaMateriales(componentePatron.getListaDeMateriales().getEstado());
			
			listaComponentesPatronDTO.add(componentePatronDTO);
		}

		return listaComponentesPatronDTO;
	}
	
	/**
	 * Método que busca todos los componentes existentes, sin discriminar sus planos y versiones.
	 */
	public List<ComponentePatronDTO> buscarComponentesPatron() {

		List<ComponentePatron> listaComponentesPatron = new LinkedList<ComponentePatron>();
		List<ComponentePatronDTO> listaComponentesPatronDTO = new LinkedList<ComponentePatronDTO>();
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		listaComponentesPatron = adminIngenieria.buscarComponentesPatron();
		
		for(ComponentePatron componentePatron: listaComponentesPatron) {
			
			ComponentePatronDTO componentePatronDTO = new ComponentePatronDTO();
			componentePatronDTO.setCodigoClase(componentePatron.getSubclaseEquipoPatron().getId().getCodigoClaseEquipoPatron());
			componentePatronDTO.setCodigoSubclase(componentePatron.getSubclaseEquipoPatron().getId().getCodigoSubclaseEquipoPatron());
			componentePatronDTO.setCodigoComponente(componentePatron.getCodigoComponente());
			componentePatronDTO.setCodigoSubcomponente(componentePatron.getCodigoSubcomponente());
			componentePatronDTO.setNombre(componentePatron.getNombre());
			componentePatronDTO.setPlano(componentePatron.getPlano());
			componentePatronDTO.setNroVersion(componentePatron.getNroVersion());
			componentePatronDTO.setDescripcionTecnica(componentePatron.getDescripcionTecnica());
			componentePatronDTO.setCantidadDisponible(componentePatron.getCantidadDisponible());
			
			listaComponentesPatronDTO.add(componentePatronDTO);
		}

		return listaComponentesPatronDTO;
	}
	
	
	/**
	 * Método que busca todos los componentes existentes en almacén. Considerar que pueden existir equipos en almacén que están activos y que
	 * no están activos.
	 */
	public List<ComponentePatronDTO> buscarComponentesPatronEnAlmacen() {

		List<ComponentePatron> listaComponentesPatron = new LinkedList<ComponentePatron>();
		List<ComponentePatronDTO> listaComponentesPatronDTO = new LinkedList<ComponentePatronDTO>();
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		listaComponentesPatron = adminIngenieria.buscarComponentesPatronEnAlmacen();
		
		for(ComponentePatron componentePatron: listaComponentesPatron) {
			
			ComponentePatronDTO componentePatronDTO = new ComponentePatronDTO();
			componentePatronDTO.setCodigoClase(componentePatron.getSubclaseEquipoPatron().getId().getCodigoClaseEquipoPatron());
			componentePatronDTO.setCodigoSubclase(componentePatron.getSubclaseEquipoPatron().getId().getCodigoSubclaseEquipoPatron());
			componentePatronDTO.setCodigoComponente(componentePatron.getCodigoComponente());
			componentePatronDTO.setCodigoSubcomponente(componentePatron.getCodigoSubcomponente());
			componentePatronDTO.setNombre(componentePatron.getNombre());
			componentePatronDTO.setPlano(componentePatron.getPlano());
			componentePatronDTO.setNroVersion(componentePatron.getNroVersion());
			componentePatronDTO.setDescripcionTecnica(componentePatron.getDescripcionTecnica());
			componentePatronDTO.setCantidadDisponible(componentePatron.getCantidadDisponible());
			
			listaComponentesPatronDTO.add(componentePatronDTO);
		}

		return listaComponentesPatronDTO;
	}
	
	@Override
	public String buscarUltimaVersionEquipoPatron(EquipoPatronDTO equipoPatronDTO) throws IllegalArgumentException {

		String version = "M0";
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		version = adminIngenieria.buscarUltimaVersionEquipoPatron(equipoPatronDTO.getCodigoClase(), equipoPatronDTO.getCodigoSubclase(), equipoPatronDTO.getPlano());
		
		equipoPatronDTO.setNroVersion(version);
		
		return version;
	}
	
	
	@Override
	public EquipoPatronDTO registrarEquipoPatron(EquipoPatronDTO equipoPatronDTO) {

		/// se crea la estructura necesaria para guardar la entidad equipoPatron
		EquipoPatron equipoPatron = new EquipoPatron();
		
		equipoPatron.setPlano(equipoPatronDTO.getPlano());
		equipoPatron.setNroVersion(equipoPatronDTO.getNroVersion());
		equipoPatron.setDescripcionTecnica(equipoPatronDTO.getDescripcionTecnica());
		equipoPatron.setPuntoPedido(equipoPatronDTO.getPuntoPedido());
		equipoPatron.setLote(equipoPatronDTO.getLote());
		equipoPatron.setCantidadDisponible(equipoPatronDTO.getCantidadDisponible());
		equipoPatron.setActivo(equipoPatronDTO.isActivo());
		
		ListaDeMateriales listaDeMateriales = new ListaDeMateriales();
		listaDeMateriales.setEstado("PROVISORIA");
		
		equipoPatron.setListaDeMateriales(listaDeMateriales);
		
		ClaseEquipoPatron claseEquipoPatron = new ClaseEquipoPatron();		
		claseEquipoPatron.setCodigoClaseEquipoPatron(equipoPatronDTO.getCodigoClase());		
		claseEquipoPatron.setNombre(equipoPatronDTO.getNombreClase());

		SubclaseEquipoPatron subclaseEquipoPatron = new SubclaseEquipoPatron();
		subclaseEquipoPatron.setClaseEquipoPatron(claseEquipoPatron);
		subclaseEquipoPatron.setNombre(equipoPatronDTO.getNombreSubclase());
		// se crea la clave compuesta con los correspondientes códigos
		subclaseEquipoPatron.setId(new SubclaseEquipoPatronId(equipoPatronDTO.getCodigoSubclase(), equipoPatronDTO.getCodigoClase()));
		
		equipoPatron.setSubclaseEquipoPatron(subclaseEquipoPatron);
		///
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		boolean exito = adminIngenieria.registrarEquipoPatron(equipoPatron);
		
		if (exito) {
			return equipoPatronDTO;
		}
		
		else {
			return null;
		}			
	}
	
	@Override
	public EquipoPatronDTO registrarEquipoPatronNuevoPlanoOVersion(EquipoPatronDTO equipoPatronBase) {
	
		/// se crea la estructura necesaria para guardar la entidad equipoPatron
		EquipoPatron equipoPatron = new EquipoPatron();
		
		equipoPatron.setPlano(equipoPatronBase.getPlano());
		equipoPatron.setNroVersion(equipoPatronBase.getNroVersion());
		equipoPatron.setDescripcionTecnica(equipoPatronBase.getDescripcionTecnica());
		equipoPatron.setPuntoPedido(equipoPatronBase.getPuntoPedido());
		equipoPatron.setLote(equipoPatronBase.getLote());
		equipoPatron.setCantidadDisponible(equipoPatronBase.getCantidadDisponible());
		equipoPatron.setActivo(equipoPatronBase.isActivo());
		
		ListaDeMateriales listaDeMateriales = new ListaDeMateriales();
		listaDeMateriales.setEstado("PROVISORIA");
		
		equipoPatron.setListaDeMateriales(listaDeMateriales);		
		
		ClaseEquipoPatron claseEquipoPatron = new ClaseEquipoPatron();		
		claseEquipoPatron.setCodigoClaseEquipoPatron(equipoPatronBase.getCodigoClase());		
		claseEquipoPatron.setNombre(equipoPatronBase.getNombreClase());
	
		SubclaseEquipoPatron subclaseEquipoPatron = new SubclaseEquipoPatron();
		subclaseEquipoPatron.setClaseEquipoPatron(claseEquipoPatron);
		subclaseEquipoPatron.setNombre(equipoPatronBase.getNombreSubclase());
		// se crea la clave compuesta con los correspondientes códigos
		subclaseEquipoPatron.setId(new SubclaseEquipoPatronId(equipoPatronBase.getCodigoSubclase(), equipoPatronBase.getCodigoClase()));
		
		equipoPatron.setSubclaseEquipoPatron(subclaseEquipoPatron);
		///
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		boolean exito = adminIngenieria.registrarEquipoPatronNuevoPlanoOVersion(equipoPatron, equipoPatronBase.getIdListaDeMateriales());
		
		if (exito) {
			return equipoPatronBase;
		}
		
		else {
			return null;
		}				
	}

	@Override
	public ComponentePatronDTO registrarComponentePatronNuevoPlanoOVersion(ComponentePatronDTO componentePatronBase) {
		
		/// se crea la estructura necesaria para guardar la entidad componentePatron
		ComponentePatron componentePatron = new ComponentePatron();
		
		componentePatron.setPlano(componentePatronBase.getPlano());
		componentePatron.setNroVersion(componentePatronBase.getNroVersion());
		componentePatron.setDescripcionTecnica(componentePatronBase.getDescripcionTecnica());
		componentePatron.setPuntoPedido(componentePatronBase.getPuntoPedido());
		componentePatron.setLote(componentePatronBase.getLote());
		componentePatron.setCantidadDisponible(componentePatronBase.getCantidadDisponible());
		componentePatron.setActivo(componentePatronBase.isActivo());
		componentePatron.setCodigoComponente(componentePatronBase.getCodigoComponente());
		componentePatron.setCodigoSubcomponente(componentePatronBase.getCodigoSubcomponente());
		componentePatron.setNombre(componentePatronBase.getNombre());
		
		ListaDeMateriales listaDeMateriales = new ListaDeMateriales();
		listaDeMateriales.setEstado("PROVISORIA");
		
		componentePatron.setListaDeMateriales(listaDeMateriales);		
		
		ClaseEquipoPatron claseEquipoPatron = new ClaseEquipoPatron();		
		claseEquipoPatron.setCodigoClaseEquipoPatron(componentePatronBase.getCodigoClase());
		
		// cuando se trae el ComponentePatron, no se inicializan los nombres de clase ni de subclase
//		claseEquipoPatron.setNombre(componentePatronBase.getNombreClase());
	
		SubclaseEquipoPatron subclaseEquipoPatron = new SubclaseEquipoPatron();
		subclaseEquipoPatron.setClaseEquipoPatron(claseEquipoPatron);
		
//		subclaseEquipoPatron.setNombre(equipoPatronBase.getNombreSubclase());
		
		// se crea la clave compuesta con los correspondientes códigos
		subclaseEquipoPatron.setId(new SubclaseEquipoPatronId(componentePatronBase.getCodigoSubclase(), componentePatronBase.getCodigoClase()));
				
		componentePatron.setSubclaseEquipoPatron(subclaseEquipoPatron);
		///
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		boolean exito = adminIngenieria.registrarComponentePatronNuevoPlanoOVersion(componentePatron, componentePatronBase.getIdListaMateriales());
		
		if (exito) {
			return componentePatronBase;
		}
		
		else {
			return null;
		}				
	}

	@Override
	public ComponentePatronDTO registrarComponentePatron(ComponentePatronDTO componenteDTO) {
		
		boolean exito = false;
		int idComponentePatron = -1;
		
		/// se crea la estructura necesaria para guardar la entidad componente patrón
		
		ComponentePatron componente = new ComponentePatron();
		
		componente.setActivo(componenteDTO.isActivo());
		componente.setCantidadDisponible(componenteDTO.getCantidadDisponible());
		componente.setCodigoComponente(componenteDTO.getCodigoComponente());
		componente.setCodigoSubcomponente(componenteDTO.getCodigoSubcomponente());
		componente.setDescripcionTecnica(componenteDTO.getDescripcionTecnica());
		
		ListaDeMateriales listaDeMateriales = new ListaDeMateriales();
		listaDeMateriales.setEstado("PROVISORIA");
		
		componente.setListaDeMateriales(listaDeMateriales);
		componente.setLote(componenteDTO.getLote());
		componente.setNombre(componenteDTO.getNombre());
		componente.setNroVersion(componenteDTO.getNroVersion());
		componente.setPlano(componenteDTO.getPlano());
		componente.setPuntoPedido(componenteDTO.getPuntoPedido());
		
		ClaseEquipoPatron claseEquipoPatron = new ClaseEquipoPatron();		
		claseEquipoPatron.setCodigoClaseEquipoPatron(componenteDTO.getCodigoClase());		

		SubclaseEquipoPatron subclaseEquipoPatron = new SubclaseEquipoPatron();
		subclaseEquipoPatron.setClaseEquipoPatron(claseEquipoPatron);
		// se crea la clave compuesta con los correspondientes códigos
		subclaseEquipoPatron.setId(new SubclaseEquipoPatronId(componenteDTO.getCodigoSubclase(), componenteDTO.getCodigoClase()));
		
		componente.setSubclaseEquipoPatron(subclaseEquipoPatron);
		
		///
			
		Ingenieria adminIngenieria = new Ingenieria();
		
		// se registra el componente patrón
		idComponentePatron = adminIngenieria.registrarComponentePatron(componente);
		
		if (idComponentePatron != -1) {
			
			// se procede a registrar el renglón de lista de materiales del equipo contenedor al que pertenece el componente
			
			// se buscan los renglones de lista de materiales
			List<RenglonListaMateriales> listaRenglones = adminIngenieria.buscarRenglonesListaMateriales(componenteDTO.getIdListaMaterialesEquipoContenedor());
			
			// se calcula el siguiente número de renglón
			
			int sgteIdRenglon = 0;
			
			if (!listaRenglones.isEmpty()) {
				sgteIdRenglon = listaRenglones.get(listaRenglones.size() - 1).getId().getIdRenglonListaMateriales() + 1;
			}
			
			// se arma la entidad renglón de lista de materiales
			
			RenglonListaMateriales renglon = new RenglonListaMateriales();
			
			renglon.setCantidad(1);
			renglon.setComponentePatron(componente);
			// se setea la clave compuesta, con el id de la lista de materiales a la que pertenece el renglón (la del equipo contenedor), y el id del renglón de la lista de materiales.
			renglon.setId(new RenglonListaMaterialesId(componenteDTO.getIdListaMaterialesEquipoContenedor(), sgteIdRenglon));
			renglon.setListaDeMateriales(componente.getListaDeMateriales());
			
			// se incluye al componente patrón en la lista de materiales de su equipo contenedor		
			exito = adminIngenieria.registrarRenglonListaDeMateriales(renglon);
			
			if (exito) {
				return componenteDTO;
			}
			
			else {
				return null;
			}
			
		}
				
		else {
			return null;
		}			
	}

	/**
	 * Método que actualiza el equipo patrón pasado como parámetro.
	 */
	@Override
	public Boolean actualizarEquipoPatron(EquipoPatronDTO equipoPatronDTO) {

		int filasActualizadas;
		boolean resultado;
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		filasActualizadas = adminIngenieria.actualizarEquipoPatron(equipoPatronDTO);
		
		// si se actualizó el equipo patrón, éxito.
		if (filasActualizadas == 1) {
			resultado = true;
		}
		
		else {
			resultado = false;
		}
		
		return resultado;
	}
	
	/**
	 * Método que actualiza el componente patrón pasado como parámetro.
	 */
	@Override
	public boolean actualizarComponentePatron(ComponentePatronDTO componentePatron) {

		int filasActualizadas;
		boolean resultado;
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		filasActualizadas = adminIngenieria.actualizarComponentePatron(componentePatron);
		
		// si se actualizó el equipo patrón, éxito.
		if (filasActualizadas == 1) {
			resultado = true;
		}
		
		else {
			resultado = false;
		}
		
		return resultado;
	}

	/**
	 * Método que busca todas las clases de productos cargadas en la base de datos
	 */
	public List<ClaseProductoDTO> buscarClasesProducto()
	{
		D_ClaseProducto claseProductoDominio = new D_ClaseProducto();
		List<ClaseProducto> clasesProducto;
		List<ClaseProductoDTO> clasesProductoDTO = new LinkedList<ClaseProductoDTO>();
		
		//buscamos todas las clases de producto de la base de datos
		clasesProducto = claseProductoDominio.buscarClasesProducto();

		//cargamos el objeto DTO
		for(ClaseProducto claseProducto : clasesProducto)
		{
			ClaseProductoDTO claseProductoDTO = new ClaseProductoDTO();
			
			claseProductoDTO.setCodigo(claseProducto.getCodigoClaseProducto());
			claseProductoDTO.setNombre(claseProducto.getNombre());
			
			//agregamos la clase de producto a la lista de clases de producto
			clasesProductoDTO.add(claseProductoDTO);
		}
		
		return clasesProductoDTO;
	}
	
	/**
	 * Método que buscan en la base de datos los elementos que pertenezcan al código de clase
	 * que se pasa como parámetro	
	 */
	public List<ElementoProductoDTO> buscarElementosProducto(int codigoClase)
	{
		D_ElementoProducto elementoProductoDominio = new D_ElementoProducto();
		List<ElementoProducto> elementosProducto;
		List<ElementoProductoDTO> elementosProductoDTO = new LinkedList<ElementoProductoDTO>();
		
		//buscamos todos los elementos de producto que pertenezcan al codigo de clase
		elementosProducto = elementoProductoDominio.buscarElementosProductos(codigoClase);
		
		//cargamos el objeto DTO
		for(ElementoProducto elementoProducto : elementosProducto)
		{
			ElementoProductoDTO elementoProductoDTO = new ElementoProductoDTO();
			
			elementoProductoDTO.setCodigo(elementoProducto.getId().getCodigoElementoProducto());
			elementoProductoDTO.getClase().setCodigo(elementoProducto.getId().getCodigoClaseProducto());
			elementoProductoDTO.setNombre(elementoProducto.getNombre());
			elementoProductoDTO.setTipoDimension(elementoProducto.getTipoDimension());
			
			//agregamos el elemento a la lista de elementos de producto
			elementosProductoDTO.add(elementoProductoDTO);
		}
		
		return elementosProductoDTO;
	}
	
	/**
	 * Método que busca en la base de datos todos los materiales de producto cargados
	 */
	public List<MaterialProductoDTO> buscarMaterialesProducto()
	{
		D_MaterialProducto materialProductoDominio = new D_MaterialProducto();
		List<MaterialProducto> materialesProducto;
		List<MaterialProductoDTO> materialesProductoDTO = new LinkedList<MaterialProductoDTO>();
		
		//buscamos los materiales en la base de datos
		materialesProducto = materialProductoDominio.buscarMaterialesProducto();
		
		//llenamos los objetos DTO
		for(MaterialProducto materialProducto : materialesProducto)
		{
			MaterialProductoDTO materialProductoDTO = new MaterialProductoDTO();
			
			materialProductoDTO.setCodigo(materialProducto.getCodigoMaterialProducto());
			materialProductoDTO.setNombre(materialProducto.getNombre());
			
			//cargamos el material a la lista de materiales
			materialesProductoDTO.add(materialProductoDTO);
		}
		
		return materialesProductoDTO;
	}
	
	@Override
	public List<MaterialProductoDTO> buscarMaterialesProducto(int codigoClase, int codigoElemento) {
		D_MaterialProducto materialProductoDominio = new D_MaterialProducto();
		List<MaterialProducto> materialesProducto;
		List<MaterialProductoDTO> materialesProductoDTO = new LinkedList<MaterialProductoDTO>();
		
		//buscamos los materiales en la base de datos
		materialesProducto = materialProductoDominio.buscarMaterialesProducto(codigoClase, codigoElemento);
		
		//llenamos los objetos DTO
		for(MaterialProducto materialProducto : materialesProducto)
		{
			MaterialProductoDTO materialProductoDTO = new MaterialProductoDTO();
			
			materialProductoDTO.setCodigo(materialProducto.getCodigoMaterialProducto());
			materialProductoDTO.setNombre(materialProducto.getNombre());
			
			//cargamos el material a la lista de materiales
			materialesProductoDTO.add(materialProductoDTO);
		}
		
		return materialesProductoDTO;
	}
	
	
	@Override
	public List<MedidaFijaProductoDTO> buscarMedidasFijasProducto(int codigoClase, int codigoElemento, int codigoMaterial) {

		D_MedidaFijaProducto medidaFijaDominio = new D_MedidaFijaProducto();
		List<MedidaFijaProducto> medidasFijasProducto;
		List<MedidaFijaProductoDTO> medidasFijasProductoDTO = new LinkedList<MedidaFijaProductoDTO>();
		
		//buscamos las medidas fijas en la base de datos
		medidasFijasProducto = medidaFijaDominio.buscarMedidasFijasProducto(codigoClase, codigoElemento, codigoMaterial);
		
		//llenamos los objetos DTO
		for(MedidaFijaProducto medidaFijaProducto : medidasFijasProducto)
		{
			MedidaFijaProductoDTO medidaFijaProductoDTO = new MedidaFijaProductoDTO();
			
			medidaFijaProductoDTO.setCodigo(medidaFijaProducto.getCodigoMedidaFijaProducto());
			medidaFijaProductoDTO.setMedida(medidaFijaProducto.getMedida());
			
			//cargamos la medida fija a la lista de materiales
			medidasFijasProductoDTO.add(medidaFijaProductoDTO);
		}
		
		return medidasFijasProductoDTO;
		
	}
	
	
	/**
	 * Método que busca en la base de datos todas las medidas fijas cargadas
	 */
	public List<MedidaFijaProductoDTO> buscarMedidasFijaProducto()
	{
		D_MedidaFijaProducto medidaFijaProductoDominio = new D_MedidaFijaProducto();
		List<MedidaFijaProducto> medidasFijasProducto;
		List<MedidaFijaProductoDTO> medidasFijasProductoDTO = new LinkedList<MedidaFijaProductoDTO>();
		
		//buscamos todas las medidas fijas en la base de datos
		medidasFijasProducto = medidaFijaProductoDominio.buscarMedidasFijaProducto();
		
		//inicializamos los objetos DTO
		for(MedidaFijaProducto medidaFija : medidasFijasProducto)
		{
			MedidaFijaProductoDTO medidaFijaDTO = new MedidaFijaProductoDTO();
			
			medidaFijaDTO.setCodigo(medidaFija.getCodigoMedidaFijaProducto());
			medidaFijaDTO.setMedida(medidaFija.getMedida());
			
			//agregamos la medida fija a la lista de medidas fijas
			medidasFijasProductoDTO.add(medidaFijaDTO);
		}
		
		return medidasFijasProductoDTO;
	}
	
	/**
	 * Método que busca en la base de datos un proveedor con el nombre pasado como parámetro
	 */
	public ProveedorDTO buscarProveedor(String nombre)
	{
		D_Proveedor proveedorDominio = new D_Proveedor();
		Proveedor proveedor;
		ProveedorDTO proveedorDTO = new ProveedorDTO();
	
		proveedor = proveedorDominio.getProveedorPorNombre(nombre);
		
		proveedorDTO.setCodigo(proveedor.getCodigoProveedor());	
		proveedorDTO.setNombre(proveedor.getNombre());
		proveedorDTO.setRubro(proveedor.getRubro());
		proveedorDTO.setTelefono(proveedor.getTelefono());
		proveedorDTO.setMail(proveedor.getMail());		
		
		return proveedorDTO;	
	}
	
	
	/**
	 * Méoto que guarda en la base de datos el producto pasado como parámetro.
	 * Retorna el id del producto recientemente guardado.
	 */
	public Integer registrarProducto(ProductoDTO productoDTO) throws Exception
	{
		Producto producto = new Producto();
		ElementoProducto elemento;
		ClaseProducto clase;
		MaterialProducto material;
		MedidaFijaProducto medidaFija;
				
		//buscamos en la base de datos el elemento del produco a registrar
		D_ElementoProducto elementoProductoDominio = new D_ElementoProducto();
		
		int codigoElemento = productoDTO.getElemento().getCodigo();
		int codigoClase = productoDTO.getElemento().getClase().getCodigo();
		
		elemento = elementoProductoDominio.buscarElementoProducto(codigoElemento, codigoClase);
		
		//si no existe el elemento en la base de datos, lo creamos
		if(elemento == null)
		{
			
			//buscamos en la base de datos la clase de producto del produco a registrar
			D_ClaseProducto claseProductoDominio = new D_ClaseProducto();
			clase = claseProductoDominio.buscarClaseProducto(productoDTO.getElemento().getClase().getCodigo());
			
			//si no existe la clase en la base de datos, la creamos
			if(clase == null)
			{
				String nombreClase = productoDTO.getElemento().getClase().getNombre().toUpperCase();
				
				//buscamos en la base de datos si existe una clase con el nombre de la clase a crear
				if(claseProductoDominio.buscarClaseProducto(nombreClase) != null)
					throw new Exception("Ya existe una clase con el nombre de clase ingresado.");								
				
				
				clase = new ClaseProducto();
				
				clase.setCodigoClaseProducto(productoDTO.getElemento().getClase().getCodigo());
				clase.setNombre(nombreClase);
			}
			
			String nombreElemento = productoDTO.getElemento().getNombre().toUpperCase();
			
			//buscamos en la base de datos si existe una elemento con el nombre de la elemento a crear
			if(elementoProductoDominio.buscarElementoProducto(nombreElemento) != null)
				throw new Exception("Ya existe un elemento con el nombre de elemento ingresado.");
			
			//creamos el elemento con sus datos			
			elemento = new ElementoProducto();
			
			elemento.setNombre(nombreElemento);
			elemento.setTipoDimension(productoDTO.getElemento().getTipoDimension());
			elemento.setClaseProducto(clase);
			
			ElementoProductoId idElemento = new ElementoProductoId();
			idElemento.setCodigoClaseProducto(clase.getCodigoClaseProducto());
			idElemento.setCodigoElementoProducto(productoDTO.getElemento().getCodigo());
			elemento.setId(idElemento);
		}
		
		
		//buscamos en la base de datos de datos si existe el material
		D_MaterialProducto materialProductoDominio = new D_MaterialProducto();
		
		material = materialProductoDominio.buscarMaterialProducto(productoDTO.getMaterial().getCodigo());
		
		//si el material no existe en la base de datos, lo creamos
		if(material == null)
		{
			String nombreMaterial = productoDTO.getMaterial().getNombre().toUpperCase();
			
			if(materialProductoDominio.buscarMaterialProducto(nombreMaterial) != null)
				throw new Exception("Ya existe un material con el nombre de material ingresado.");
			
			
			material = new MaterialProducto();
			
			material.setCodigoMaterialProducto(0);
			material.setNombre(nombreMaterial);
			
		}
		
		
		
		//buscamos en la base en la datos si existe la medida fija
		D_MedidaFijaProducto medidaFijaProductoDominio = new D_MedidaFijaProducto();
		
		String medida = productoDTO.getMedidaFija().getMedida().toLowerCase();
		
		//quitamos los espacios a la medida fija para buscar en la base de datos medidas fijas equivalentes
		String medidaSinEspacios = medida.replaceAll(" ", "");
		
		medidaFija = medidaFijaProductoDominio.buscarMedidaFija(medidaSinEspacios);
		
		//si no existe la medida fija en la base de datos, la creamos
		if(medidaFija == null)
		{
			medidaFija = new MedidaFijaProducto();
			
			medidaFija.setCodigoMedidaFijaProducto(0);
			medidaFija.setMedida(medida);		
		}
		
		
		//asignamos los objetos al producto
		producto.setElementoProducto(elemento);
		producto.setMaterialProducto(material);
		producto.setMedidaFijaProducto(medidaFija);
		producto.setActivo(true); 
		
		//registramos el producto en la base de datos
		D_Producto productoDominio = new D_Producto();
		
		
		int idElemento = elemento.getId().getCodigoElementoProducto();
		int idClase = elemento.getId().getCodigoClaseProducto();
		int idMaterial = material.getCodigoMaterialProducto();
		int idMedida = medidaFija.getCodigoMedidaFijaProducto();
				
		if(idElemento != 0 && idClase != 0 && idMaterial != 0 && idMedida != 0){
			//buscamos en la base de datos un producto que coincida con el que estamos tratando de crear con el elemento, material y medida fija
			Producto p = productoDominio.buscarProducto(elemento, material, medidaFija);
			
			//si ya hay un producto con los datos ingresados
			if(p != null)
				throw new Exception("Ya existe un producto con los datos cargados.");
		}
		
		productoDominio.registrarProducto(producto);
		
		return producto.getIdProducto();
	}
	
	
	/**
	 * Método que guarda en la base de datos las medidas variables estándares del producto pasado como parámentro.
	 */
	public Boolean registrarMedidasVariablesEstandar(int idProducto, List<MedidaVariableEstandarDTO> medidasDTO)
	{
		D_Producto productoDominio = new D_Producto();
		D_MedidaVariableEstandarProducto medidaVariableEstandarDominio = new D_MedidaVariableEstandarProducto();
		
		List<MedidasVariablesEstandar> medidas = new LinkedList<MedidasVariablesEstandar>();
		
		//buscamos el producto al cual se le aplicarán las medidas variables estándar
		Producto producto = productoDominio.buscarProducto(idProducto);
		
		//eliminar cualquier medida que pueda tener cargado el producto
		medidaVariableEstandarDominio.eliminarMedidasVariablesEstandar(producto);
		
		//por cada medidaDTO que viene como parámetro, creamos la medida y la agregamos a la lista de medidas
		for(MedidaVariableEstandarDTO medidaDTO : medidasDTO)
		{
			MedidasVariablesEstandar medida = new MedidasVariablesEstandar();
			
			MedidasVariablesEstandarId idMedida = new MedidasVariablesEstandarId();
			
			idMedida.setIdProducto(producto.getIdProducto());
			idMedida.setMedidaVariable1(medidaDTO.getMedidaVariable1());
			idMedida.setMedidaVariable2(medidaDTO.getMedidaVariable2());
			
			medida.setId(idMedida);
			medida.setProducto(producto);
			
			medidas.add(medida);
		}
		
		//guardamos la lista de medidas en la base de datos
		medidaVariableEstandarDominio.registrarMedidasVariablesEstandar(medidas);
		
		return true;
	}
	
	/**
	 * Método que registra el inventario de un producto en la base de datos
	 * @param idProducto. Id del producto del inventario.
	 */
	public Boolean registrarInventario(int idProducto, List<MedidaVariableEstandarDTO> medidasDTO)
	{
		
		//verificamos si existe un registro de inventario para el producto
		D_Inventario inventarioDominio = new D_Inventario();
		
		for(MedidaVariableEstandarDTO medida : medidasDTO)
		{
			String medida1 = String.valueOf(medida.getMedidaVariable1());
			String medida2 = String.valueOf(medida.getMedidaVariable2());
			
			//si no existe el inventario para el producto, lo creamos
			if(inventarioDominio.buscarPorProducto(idProducto, medida1, medida2) == null)
			{
				//buscamos el producto
				D_Producto productoDominio = new D_Producto();
				Producto producto = productoDominio.buscarProducto(idProducto);
				
				//creamos el inventario
				Inventario inventario = new Inventario();
				
				inventario.setProducto(producto);
				inventario.setCantidadDisponible(0);
				inventario.setCantDisponiblePendienteEntrega(0);
				inventario.setMedida1(medida1);
				inventario.setMedida2(medida2);
				
				//registramos el inventario en la base de datos
				inventarioDominio.registrar(inventario);
			}
		}
		
		return true;
	}
	
	/**
	 * Método que guarda en la base de datos la relación entre un proveedor y un producto, indicándose
	 * que dicho proveedor provee el producto en cuestión. 
	 */
	public Boolean registrarProveedorDeProducto(int idProducto, List<ProveedorDTO> proveedores)
	{
		D_ProveedorDeProducto proveedorDeProductoDominio = new D_ProveedorDeProducto();
		D_Producto productoDominio = new D_Producto();
		D_Proveedor proveedorDominio = new D_Proveedor();
		
		//buscamos el prducto con el id que se pasó como parámetro
		Producto producto = productoDominio.buscarProducto(idProducto);
		
		//eliminamos todos los proveedores del producto
		proveedorDeProductoDominio.eliminarTodosProveedores(producto);
		
		//cargamos los nuevos proveedores del producto
		for(ProveedorDTO proveedor : proveedores)
		{
			ProveedorDeProducto proveedorDeProducto = new ProveedorDeProducto();
			Proveedor p = new Proveedor();
						
			p = proveedorDominio.buscarProveedor(proveedor.getCodigo());
			
			//creamos el id del proveedor de producto
			ProveedorDeProductoId idProveedorDeProducto = new ProveedorDeProductoId();
			idProveedorDeProducto.setIdProducto(producto.getIdProducto());
			idProveedorDeProducto.setIdProveedor(p.getCodigoProveedor());
			
			//cargamos los datos del proveedor de producto
			proveedorDeProducto.setId(idProveedorDeProducto);
			proveedorDeProducto.setProducto(producto);
			proveedorDeProducto.setProveedor(p);
			proveedorDeProducto.setPrecio(0);
			
			proveedorDeProductoDominio.registrarProveedorDeProducto(proveedorDeProducto);
		}
		
		return true;
	}
	
	
	/**
	 * Méotodo que busca en la base de datos todos los prodctos cargados.
	 */
	public List<ProductoDTO> buscarProductos()
	{
		D_Producto productoDominio = new D_Producto();
		List<ProductoDTO> productosDTO = new LinkedList<ProductoDTO>();
		List<Producto> productos;
		
		productos = productoDominio.buscarProductos();
		
		for(Producto producto : productos)
		{
			//cargamos el producto a la lista de productos sólo si este no se dió de baja
			if(producto.isActivo()){
				ProductoDTO productoDTO = new ProductoDTO();
				
				productoDTO.setIdProducto(producto.getIdProducto());
				
				//creamos la clase del producto y se la asignamos al elemento del producto
				ClaseProductoDTO claseDTO = new ClaseProductoDTO();
				claseDTO.setCodigo(producto.getElementoProducto().getClaseProducto().getCodigoClaseProducto());
				claseDTO.setNombre(producto.getElementoProducto().getClaseProducto().getNombre());
				
				//creamos el elemento del producto
				ElementoProductoDTO elementoDTO = new ElementoProductoDTO();
				elementoDTO.setCodigo(producto.getElementoProducto().getId().getCodigoElementoProducto());
				elementoDTO.setClase(claseDTO);
				elementoDTO.setNombre(producto.getElementoProducto().getNombre());
				elementoDTO.setTipoDimension(producto.getElementoProducto().getTipoDimension());
				
				//asignamos el elemento al producto
				productoDTO.setElemento(elementoDTO);
				
				//creamos el material y se lo asignamos al producto
				MaterialProductoDTO materialDTO = new MaterialProductoDTO();
				materialDTO.setCodigo(producto.getMaterialProducto().getCodigoMaterialProducto());
				materialDTO.setNombre(producto.getMaterialProducto().getNombre());
				
				productoDTO.setMaterial(materialDTO);
				
				//creamos la medida fija y se la asignamos al producto
				MedidaFijaProductoDTO medidaFija = new MedidaFijaProductoDTO();
				medidaFija.setCodigo(producto.getMedidaFijaProducto().getCodigoMedidaFijaProducto());
				medidaFija.setMedida(producto.getMedidaFijaProducto().getMedida());
				
				productoDTO.setMedidaFija(medidaFija);
				
				productosDTO.add(productoDTO);
			}
		}
		return productosDTO;
	}
	
	
	/**
	 * Método que busca en la base de datos todos los productos que coinciden con los parámetros.
	 */
	public List<ProductoDTO> buscarProductos(int codigoClase, int codigoElemento, int codigoMaterial)
	{
		D_Producto productoDominio = new D_Producto();
		List<Producto> productos;
		List<ProductoDTO> productosDTO = new LinkedList<ProductoDTO>();
				
		//buscamos todos los productos que tengan como elemento y material los pasados como parámetro
		productos = productoDominio.buscarProductos(codigoClase, codigoElemento, codigoMaterial);
		
		for(Producto producto : productos)
		{
			//cargamos el producto a la lista de productos sólo si este no se dió de baja
			if(producto.isActivo()){
				ProductoDTO productoDTO = new ProductoDTO();
				
				productoDTO.setIdProducto(producto.getIdProducto());
				
				//creamos la clase del producto y se la asignamos al elemento del producto
				ClaseProductoDTO claseDTO = new ClaseProductoDTO();
				claseDTO.setCodigo(producto.getElementoProducto().getClaseProducto().getCodigoClaseProducto());
				claseDTO.setNombre(producto.getElementoProducto().getClaseProducto().getNombre());
				
				//creamos el elemento del producto
				ElementoProductoDTO elementoDTO = new ElementoProductoDTO();
				elementoDTO.setCodigo(producto.getElementoProducto().getId().getCodigoElementoProducto());
				elementoDTO.setClase(claseDTO);
				elementoDTO.setNombre(producto.getElementoProducto().getNombre());
				elementoDTO.setTipoDimension(producto.getElementoProducto().getTipoDimension());
				
				//asignamos el elemento al producto
				productoDTO.setElemento(elementoDTO);
				
				//creamos el material y se lo asignamos al producto
				MaterialProductoDTO materialDTO = new MaterialProductoDTO();
				materialDTO.setCodigo(producto.getMaterialProducto().getCodigoMaterialProducto());
				materialDTO.setNombre(producto.getMaterialProducto().getNombre());
				
				productoDTO.setMaterial(materialDTO);
				
				//creamos la medida fija y se la asignamos al producto
				MedidaFijaProductoDTO medidaFija = new MedidaFijaProductoDTO();
				medidaFija.setCodigo(producto.getMedidaFijaProducto().getCodigoMedidaFijaProducto());
				medidaFija.setMedida(producto.getMedidaFijaProducto().getMedida());
				
				productoDTO.setMedidaFija(medidaFija);
				
				//cargamos las medidas variables del producto
				for(MedidasVariablesEstandar medidaVariable : producto.getMedidasVariablesEstandars())
				{
					MedidaVariableEstandarDTO medidaVariableDTO = new MedidaVariableEstandarDTO();
										
					medidaVariableDTO.setMedidaVariable1((float) medidaVariable.getId().getMedidaVariable1());
					medidaVariableDTO.setMedidaVariable2((float) medidaVariable.getId().getMedidaVariable2());
					
					productoDTO.getMedidasEstandar().add(medidaVariableDTO);
				}
				
				productosDTO.add(productoDTO);
			}
		}
		
		return productosDTO;
	}
	
	/**
	 * Método que busca en la base de datos el producto con el id pasado como parámetro.
	 */
	public ProductoDTO buscarProducto(int idProducto) {
		
		D_Producto productoDominio = new D_Producto();
		Producto producto;
		ProductoDTO productoDTO = new ProductoDTO();
				
		//Buscamos el producto.
		producto = productoDominio.buscarProducto(idProducto);
			
		productoDTO.setIdProducto(producto.getIdProducto());
		
		//Creamos la clase del producto y se la asignamos al elemento del producto
		ClaseProductoDTO claseDTO = new ClaseProductoDTO();
		claseDTO.setCodigo(producto.getElementoProducto().getClaseProducto().getCodigoClaseProducto());
		claseDTO.setNombre(producto.getElementoProducto().getClaseProducto().getNombre());
		
		//Creamos el elemento del producto
		ElementoProductoDTO elementoDTO = new ElementoProductoDTO();
		elementoDTO.setCodigo(producto.getElementoProducto().getId().getCodigoElementoProducto());
		elementoDTO.setClase(claseDTO);
		elementoDTO.setNombre(producto.getElementoProducto().getNombre());
		elementoDTO.setTipoDimension(producto.getElementoProducto().getTipoDimension());
		productoDTO.setElemento(elementoDTO);
		
		//Creamos el material y se lo asignamos al producto.
		MaterialProductoDTO materialDTO = new MaterialProductoDTO();
		materialDTO.setCodigo(producto.getMaterialProducto().getCodigoMaterialProducto());
		materialDTO.setNombre(producto.getMaterialProducto().getNombre());
		productoDTO.setMaterial(materialDTO);
		
		//Creamos la medida fija y se la asignamos al producto
		MedidaFijaProductoDTO medidaFija = new MedidaFijaProductoDTO();
		medidaFija.setCodigo(producto.getMedidaFijaProducto().getCodigoMedidaFijaProducto());
		medidaFija.setMedida(producto.getMedidaFijaProducto().getMedida());
		productoDTO.setMedidaFija(medidaFija);
		
		//Cargamos las medidas variables del producto
		for(MedidasVariablesEstandar medidaVariable : producto.getMedidasVariablesEstandars())
		{
			MedidaVariableEstandarDTO medidaVariableDTO = new MedidaVariableEstandarDTO();
								
			medidaVariableDTO.setMedidaVariable1((float) medidaVariable.getId().getMedidaVariable1());
			medidaVariableDTO.setMedidaVariable2((float) medidaVariable.getId().getMedidaVariable2());
			
			productoDTO.getMedidasEstandar().add(medidaVariableDTO);
		}
		
		return productoDTO;
	}

	@Override
	public EquipoPatronDTO buscarEquipoPatron(int codigoClase, int codigoSubclase, int plano, String version) throws IllegalArgumentException {

		EquipoPatron equipoPatron;
		EquipoPatronDTO equipoPatronDTO = new EquipoPatronDTO();
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		// se recupera el equipo patrón.
		equipoPatron = adminIngenieria.buscarEquipoPatron(codigoClase, codigoSubclase, plano, version);
					
		// se carga el equipo patrón DTO.	
		equipoPatronDTO.setIdEquipoPatron(equipoPatron.getIdEquipoPatron());
		equipoPatronDTO.setCodigoClase(equipoPatron.getSubclaseEquipoPatron().getId().getCodigoClaseEquipoPatron());
		equipoPatronDTO.setNombreClase(equipoPatron.getSubclaseEquipoPatron().getClaseEquipoPatron().getNombre());
		equipoPatronDTO.setCodigoSubclase(equipoPatron.getSubclaseEquipoPatron().getId().getCodigoSubclaseEquipoPatron());
		equipoPatronDTO.setNombreSubclase(equipoPatron.getSubclaseEquipoPatron().getNombre());
		equipoPatronDTO.setPlano(equipoPatron.getPlano());
		equipoPatronDTO.setNroVersion(equipoPatron.getNroVersion());
		equipoPatronDTO.setDescripcionTecnica(equipoPatron.getDescripcionTecnica());
		equipoPatronDTO.setPuntoPedido(equipoPatron.getPuntoPedido());
		equipoPatronDTO.setLote(equipoPatron.getLote());
		equipoPatronDTO.setCantidadDisponible(equipoPatron.getCantidadDisponible());
		equipoPatronDTO.setActivo(equipoPatron.isActivo());
		equipoPatronDTO.setIdListaDeMateriales(equipoPatron.getListaDeMateriales().getIdListaMateriales());
		equipoPatronDTO.setEstadoListaMateriales(equipoPatron.getListaDeMateriales().getEstado());
			
		return equipoPatronDTO;
	}
	
	/**
	 * Método que busca en la base de datos todos los datos del proveedor
	 * @param nombre. Nombre del proveedor que se busca
	 * @return ProveedorDTO. Retorna el proveedor con todos sus datos.
	 */
	public ProveedorDTO buscarProveedorCompleto(String nombre)
	{
		Proveedor proveedor = new Proveedor();
		ProveedorDTO proveedorDTO = new ProveedorDTO();
		D_Proveedor proveedorDominio = new D_Proveedor();
		
		//buscamos todos los datos del proveedor
		proveedor = proveedorDominio.getEmpresaCompleta(nombre);

		
		//creamos la dirección y cargamos sus datos
		DireccionDTO direccionDTO = new DireccionDTO();

		direccionDTO.setCalle(proveedor.getDireccion().getCalle());
		direccionDTO.setAltura(proveedor.getDireccion().getAltura());
		direccionDTO.setOficina(proveedor.getDireccion().getOficina());
		direccionDTO.setPiso(proveedor.getDireccion().getPiso());
		direccionDTO.setCpa(proveedor.getDireccion().getCpa());
		direccionDTO.setLocalidad(proveedor.getDireccion().getLocalidad().getNombre());
		direccionDTO.setProvincia(proveedor.getDireccion().getLocalidad().getProvincia().getNombre());
		direccionDTO.setPais(proveedor.getDireccion().getLocalidad().getProvincia().getPais().getNombre());
		direccionDTO.setCodigoLocalidad(proveedor.getDireccion().getLocalidad().getCodigoPostal());

		//cargamos los datos del proveedor
		proveedorDTO.setNombre(proveedor.getNombre());
		proveedorDTO.setCuit(proveedor.getCuit());
		proveedorDTO.setRubro(proveedor.getRubro());
		proveedorDTO.setResponsable(proveedor.getResponsable());
		proveedorDTO.setTelefono(proveedor.getTelefono());
		proveedorDTO.setFax(proveedor.getFax());
		proveedorDTO.setMail(proveedor.getMail());
		proveedorDTO.setPaginaWeb(proveedor.getPaginaWeb());
		proveedorDTO.setObservaciones(proveedor.getObservaciones());
		proveedorDTO.setTipoProveedor(proveedor.getTipoProveedor());
		proveedorDTO.setDireccion(direccionDTO);

		//cargamos la lista de contactos del proveedor
		for (Contacto contacto : proveedor.getContactos()) {

			//creamos un nuevo contacto y cargamos sus datos
			ContactoDTO contactoDTO = new ContactoDTO();
			
			contactoDTO.setNombre(contacto.getNombre());
			contactoDTO.setCargo(contacto.getCargo());
			contactoDTO.setCelular(contacto.getCelular());
			contactoDTO.setMail(contacto.getMail());
			contactoDTO.setTelefonoEmpresa(contacto.getTelefonoEmpresa());
			contactoDTO.setTelefonoParticular(contacto.getTelefonoParticular());
			contactoDTO.setInternoEmpresa(contacto.getInternoEmpresa());

			//agregamos el contacto a la lista de contactos
			proveedorDTO.getContacto().add(contactoDTO);
		}

		return proveedorDTO;
	}

	/**
	 * Método que busca todos los proveedores que proveen el producto que tiene el id pasado como parámetro.
	 */
	public List<ProveedorDTO> buscarProveedores(int idProducto)
	{
		D_ProveedorDeProducto proveedorDeProductoDominio = new D_ProveedorDeProducto();
		D_Producto productoDominio = new D_Producto();
		Producto producto;
		List<ProveedorDeProducto> proveedoresDeProducto;
		List<ProveedorDTO> proveedoresDTO = new LinkedList<ProveedorDTO>();
		
		//buscamos el producto en la base de datos
		producto = productoDominio.buscarProducto(idProducto);
		
		//buscamos los proveedores de producto que proveen el producto
		proveedoresDeProducto = proveedorDeProductoDominio.buscarProveedores(producto);
				
		for(ProveedorDeProducto proveedorDeProducto : proveedoresDeProducto)
		{
			//recuperamos el proveedor del objeto proveedor de producto
			Proveedor proveedor = proveedorDeProducto.getProveedor();
			
			//creamos un proveedor nuevo
			ProveedorDTO proveedorDTO = new ProveedorDTO();
			
			//seteamos los datos al proveedor
			proveedorDTO.setCodigo(proveedor.getCodigoProveedor());
			proveedorDTO.setNombre(proveedor.getNombre());
			proveedorDTO.setRubro(proveedor.getRubro());
			proveedorDTO.setTelefono(proveedor.getTelefono());
			proveedorDTO.setMail(proveedor.getMail());
			
			//añadimos el proveedor a la lista de proveedores
			proveedoresDTO.add(proveedorDTO);
		}
		
		return proveedoresDTO;
	}
	
	
	/**
	 * Método que elimina un producto de la base de datos
	 * @param idProducto. Es el id del producto a eliminar.
	 * @return Boolean. Si el proceso de eliminación fue exitoso, retorna true.
	 */
	public Boolean eliminarProducto(int idProducto) throws Exception
	{
		D_Producto productoDominio = new D_Producto();
		Producto producto;
		
		//buscamos el producto en la base de datos
		producto = productoDominio.buscarProductoCompleto(idProducto);
		
		//damos de baja al producto (baja lógica)
		producto.setActivo(false);
		
		//actualizamos los datos del producto en la base de datos
		productoDominio.registrarProducto(producto);
		
		return true;
	}
	
	/**
	 * Método que busca en la base de datos todas las órdenes de pedido que cumplen con los parámetros de entrada.
	 */
	public List<OrdenPedidoDTO> buscarOrdenPedido(int numeroOrden, String nombreCliente)
	{
		D_OrdenPedido ordenPedidoDominio = new D_OrdenPedido();
		List<OrdenPedido> ordenesPedido;
		List<OrdenPedidoDTO> ordenesPedidoDTO = new LinkedList<OrdenPedidoDTO>();
		
		//buscamos en la base de datos todas las ordenes de pedido que cumplen con los parámetros especificados
		ordenesPedido = ordenPedidoDominio.buscarOrdenPedido(numeroOrden, nombreCliente);
		
		//cargamos los datos del DTO
		for(OrdenPedido ordenPedido : ordenesPedido)
		{
			OrdenPedidoDTO ordenPedidoDTO = new OrdenPedidoDTO();
		
			ordenPedidoDTO.setNroOrden(ordenPedido.getNroOrden());
			ordenPedidoDTO.setFechaGeneracion(ordenPedido.getFechaGeneracion());
			
			if(ordenPedido.getCliente() != null)
				ordenPedidoDTO.setNombreCliente(ordenPedido.getCliente().getNombre());
			
			else
				ordenPedidoDTO.setNombreCliente("PLANIFICADA");
			
			ordenPedidoDTO.setFechaPrevistaEntrega(ordenPedido.getFechaPrevistaEntrega());
			ordenPedidoDTO.setObservacion(ordenPedido.getObservacion());
			
			//agregamos la orden a la lista de órdenes
			ordenesPedidoDTO.add(ordenPedidoDTO);
		}
		
		return ordenesPedidoDTO;
	}

	/**
	 * Método que coloca en estado INACTIVO al equipo patrón de la base de datos (a todas sus versiones)
	 * @param codigoEquipo. Es el código del equipo a desactivar.
	 * @return true, si hubo éxito
	 * 		   false, caso contrario
	 */
	@Override
	public boolean eliminarEquipoPatron(String codigoEquipo) {
		
		boolean exito = true;
		
		// se desglosan del código la clase, subclase, plano y versión del equipo a buscar.	
		int codigoClase = Integer.parseInt(codigoEquipo.substring(0, 2));
		int codigoSubclase = Integer.parseInt(codigoEquipo.substring(2, 4));
		int plano = Integer.parseInt(codigoEquipo.substring(13, 15));
		
		List<EquipoPatron> listaVersionesEquipoPatron;
		
		Ingenieria adminIngenieria = new Ingenieria();	
		
		// se buscan todas las versiones del equipo patrón especificado
		listaVersionesEquipoPatron = adminIngenieria.buscarEquipoPatronVersiones(codigoClase, codigoSubclase, plano);
		
		for (EquipoPatron e: listaVersionesEquipoPatron) {		
			exito = exito && adminIngenieria.eliminarEquipoPatron(e.getIdEquipoPatron());
		}
		
		return exito;
	}
	
	/**
	 * Método que coloca en estado INACTIVO al componente patrón de la base de datos.
	 * @param codigoComponenteSeleccionado. Es el código del componente a desactivar.
	 * @return true, si hubo éxito
	 * 		   false, caso contrario
	 */
	@Override
	public boolean eliminarComponentePatron(String codigoComponenteSeleccionado) {

		boolean exito = true;
		
		// se desglosa el código
		int codigoClase = Integer.parseInt(codigoComponenteSeleccionado.substring(0, 2));
		int codigoSubclase = Integer.parseInt(codigoComponenteSeleccionado.substring(2, 4));
		int codigoComponente = Integer.parseInt(codigoComponenteSeleccionado.substring(8, 10));
		int codigoSubcomponente = Integer.parseInt(codigoComponenteSeleccionado.substring(10, 12));
		
		String version = codigoComponenteSeleccionado.substring(5, 7);
		
		int plano = Integer.parseInt(codigoComponenteSeleccionado.substring(13, 15));
		
		ComponentePatron c = new ComponentePatron();

		Ingenieria adminIngenieria = new Ingenieria();	
		
		// se busca el componente a eliminar
		c = adminIngenieria.buscarComponentePatron(codigoClase, codigoSubclase, version, codigoComponente, codigoSubcomponente, plano);
		
		// se intenta eliminar el componente patrón.
		exito = adminIngenieria.eliminarComponentePatron(c.getIdComponentePatron());
		
		return exito;
	}

	/**
	 * Método que busca todos los renglones de una orden de pedido cuyos equipos/componentes no se sacan del almacén sino que se pretender producir.
	 * @param numeroOrden. Es el número de orden para la cual se quiere buscar todos sus renglones.
	 * @return List<RenglonOrdenPedidoDTO>. Devuelve una lista con los renglones de la orden de pedido.
	 */
	public List<RenglonOrdenPedidoDTO> buscarRenglonesOrdenPedido(int numeroOrden)
	{
		List<RenglonOrdenPedido> renglones;
		List<RenglonOrdenPedidoDTO> renglonesDTO = new LinkedList<RenglonOrdenPedidoDTO>();
		D_OrdenPedido ordenPedidoDominio = new D_OrdenPedido();
		
		renglones = ordenPedidoDominio.buscarRenglones(numeroOrden);
		
		for(RenglonOrdenPedido renglon : renglones)
		{
			//sólo agregamos los renglones cuyos equipos/componentes no se sacan del almacén
			if(!renglon.isEnAlmacen())
			{
				RenglonOrdenPedidoDTO renglonDTO = new RenglonOrdenPedidoDTO();
				
				renglonDTO.setId(renglon.getId().getIdRenglonOrdenPedido());			
				renglonDTO.setCantidad(renglon.getCantidad());
				
				//si el renglón tiene cargado un equipo
				if(renglon.getEquipoPatron() != null)
				{
					//generamos el código del equipo
					EquipoPatronDTO equipoDTO = new EquipoPatronDTO();
					
					equipoDTO.setCodigoClase(renglon.getEquipoPatron().getSubclaseEquipoPatron().getId().getCodigoClaseEquipoPatron());
					equipoDTO.setCodigoSubclase(renglon.getEquipoPatron().getSubclaseEquipoPatron().getId().getCodigoSubclaseEquipoPatron());
					equipoDTO.setPlano(renglon.getEquipoPatron().getPlano());
					equipoDTO.setNroVersion(renglon.getEquipoPatron().getNroVersion());
					
					renglonDTO.setCodigo(Validaciones.rellenarCodigoEquipoPatron(equipoDTO));
					renglonDTO.setEstadoListaMateriales(renglon.getEquipoPatron().getListaDeMateriales().getEstado());
					renglonDTO.setCantidadDisponible(renglon.getEquipoPatron().getCantidadDisponible());
					
					String nombreEquipo = renglon.getEquipoPatron().getSubclaseEquipoPatron().getClaseEquipoPatron().getNombre() + " - " + renglon.getEquipoPatron().getSubclaseEquipoPatron().getNombre();
					renglonDTO.setEquipoOComponente(nombreEquipo);
				}
				
				//si el renglón tiene cargado un componente
				else
				{
					//generamos el código del componente
					ComponentePatronDTO componenteDTO = new ComponentePatronDTO();
					
					componenteDTO.setCodigoClase(renglon.getComponentePatron().getSubclaseEquipoPatron().getId().getCodigoClaseEquipoPatron());
					componenteDTO.setCodigoSubclase(renglon.getComponentePatron().getSubclaseEquipoPatron().getId().getCodigoSubclaseEquipoPatron());
					componenteDTO.setPlano(renglon.getComponentePatron().getPlano());
					componenteDTO.setNroVersion(renglon.getComponentePatron().getNroVersion());
					
					renglonDTO.setCodigo(Validaciones.rellenarCodigoComponentePatron(componenteDTO));
					renglonDTO.setEstadoListaMateriales(renglon.getComponentePatron().getListaDeMateriales().getEstado());
					renglonDTO.setCantidadDisponible(renglon.getComponentePatron().getCantidadDisponible());
					
					String nombreComponente = renglon.getComponentePatron().getSubclaseEquipoPatron().getClaseEquipoPatron().getNombre() + " - " + renglon.getEquipoPatron().getSubclaseEquipoPatron().getNombre();
					renglonDTO.setEquipoOComponente(nombreComponente);
				}
				
				renglonesDTO.add(renglonDTO);
			}
		}
		
		return renglonesDTO;
	}
	
	
	/**
	 * Método que registra en la base de datos una orden de fabricación
	 */
	public Boolean registrarOrdenFabricacion(OrdenFabricacionGeneralDTO ordenFabricacionDTO) throws Exception
	{
		OrdenFabricacionGeneral ordenFabricacion = new OrdenFabricacionGeneral();
		
		//buscamos y asiganmos la orden de pedido a la orden de fabricación
		D_OrdenPedido ordenPedidoDominio = new D_OrdenPedido();
		int nroOrden = (int) ordenFabricacionDTO.getOrdenPedidoDTO().getNroOrden();
		
		OrdenPedido ordenPedido = ordenPedidoDominio.buscarOrdenPedido(nroOrden);
		ordenFabricacion.setOrdenPedido(ordenPedido);
		
		//buscamos el empleado responsable y lo asignamos a la orden de fabricación
		D_Empleado empleadoDominio = new D_Empleado();
		int idEmpleado = empleadoDominio.getIdEmpleado(ordenFabricacionDTO.getResponsable());
		Empleado empleado = empleadoDominio.getEmpleado(idEmpleado);
		ordenFabricacion.setEmpleado(empleado);
		
		//asignamos los demás valores a la orden de fabricación
		ordenFabricacion.setNroOrden(ordenFabricacionDTO.getNroOrden());
		ordenFabricacion.setFechaGeneracion(ordenFabricacionDTO.getFechaGeneracion());
		ordenFabricacion.setFechaCierre(ordenFabricacionDTO.getFechaCierre());
		ordenFabricacion.setFechaPrevistaInicio(ordenFabricacionDTO.getFechaPrevistaInicio());
		ordenFabricacion.setFechaPrevistaFinalizacion(ordenFabricacionDTO.getFechaPrevistaFinalizacion());
		ordenFabricacion.setEstado(ordenFabricacionDTO.getEstado());
		ordenFabricacion.setObservaciones(ordenFabricacionDTO.getObservaciones());
		
		//guardamos la orden de fabricación en la base de datos
		D_OrdenFabricacionGeneral ordenFabricacionDominio = new D_OrdenFabricacionGeneral();
		ordenFabricacionDominio.registrar(ordenFabricacion);
		
		
		//creamos los renglones de la orden de fabricación con los datos del DTO
		Set<RenglonOrdenFabricacionGeneral> renglones = new HashSet<RenglonOrdenFabricacionGeneral>();
		int numeroRenglon = 1;
		
		for(RenglonOrdenFabricacionGeneralDTO renglonDTO : ordenFabricacionDTO.getRenglonOrdenFabricacionGeneralsDTO())
		{
			//contador para el número de renglones
			
			
			RenglonOrdenFabricacionGeneral renglon = new RenglonOrdenFabricacionGeneral();
			
			//generamos y seteamos el id de la orden de fabricación general
			RenglonOrdenFabricacionGeneralId idRenglonOrdenFabricacion = new RenglonOrdenFabricacionGeneralId();
			idRenglonOrdenFabricacion.setIdOrdenFabricacionGeneral(ordenFabricacion.getNroOrden());
			idRenglonOrdenFabricacion.setIdRenglonOrdenFabricacion(numeroRenglon);
			renglon.setId(idRenglonOrdenFabricacion);
			
			//buscamos el renglón de la orden de pedido y se la seteamos al renglón de la orden de fabricación
			RenglonOrdenPedidoId idRenglonOrdenPedido = new RenglonOrdenPedidoId();
			idRenglonOrdenPedido.setIdRenglonOrdenPedido(renglonDTO.getRenglonOrdenPedidoDTO().getId());
			idRenglonOrdenPedido.setIdOrdenPedido(ordenPedido.getNroOrden());
			 
			RenglonOrdenPedido renglonOrdenPedido = ordenPedidoDominio.buscarRenglon(idRenglonOrdenPedido);	
			renglon.setRenglonOrdenPedido(renglonOrdenPedido);
			
			
			//seteamos los demás datos al renglón de la orden de fabricación
			renglon.setOrdenFabricacionGeneral(ordenFabricacion);
			renglon.setCantidadAProducir(renglonDTO.getCantidadAProducir());
			renglon.setFechaEstimadaFinalizacion(renglonDTO.getFechaEstimadaFinalizacion());
			renglon.setFechaEstimadaInicio(renglonDTO.getFechaEstimadaInicio());
			
			renglones.add(renglon);
			
			numeroRenglon++;
		}
		
		//guardamos los renglones de la orden de fabricación en la base de datos
		ordenFabricacionDominio.registrarRenglones(renglones);
		
		return true;
	}

	@Override
	public void actualizarEstadoOrdenFabricacion(OrdenFabricacionGeneralDTO ordenFabricacionDTO) throws Exception{
		
		D_OrdenFabricacionGeneral ordenFabricacionDominio = new D_OrdenFabricacionGeneral();
		
		OrdenFabricacionGeneral ordenFabricacion = new OrdenFabricacionGeneral();
		ordenFabricacion = ordenFabricacionDominio.buscarOrdenFabricacionGeneral(ordenFabricacionDTO.getNroOrden());
		ordenFabricacion.setEstado(ordenFabricacionDTO.getEstado());
		
		ordenFabricacionDominio.registrar(ordenFabricacion);
		
	}
	
	@Override
	public List<EquipoPatronDTO> buscarPlanosEquipoPatronActivosEInactivos(int codigoClase, int codigoSubclase) {
		
		List<EquipoPatron> listaEquiposPatron = new LinkedList<EquipoPatron>();
		List<EquipoPatronDTO> listaEquiposPatronDTO = new LinkedList<EquipoPatronDTO>();
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		listaEquiposPatron = adminIngenieria.buscarPlanosEquipoPatronActivosEInactivos(codigoClase, codigoSubclase);
		
		for(EquipoPatron equipoPatron: listaEquiposPatron) {
			
			EquipoPatronDTO equipoPatronDTO = new EquipoPatronDTO();
			
			equipoPatronDTO.setCodigoClase(equipoPatron.getSubclaseEquipoPatron().getId().getCodigoClaseEquipoPatron());
			equipoPatronDTO.setCodigoSubclase(equipoPatron.getSubclaseEquipoPatron().getId().getCodigoSubclaseEquipoPatron());
			equipoPatronDTO.setPlano(equipoPatron.getPlano());
			equipoPatronDTO.setNroVersion(equipoPatron.getNroVersion());
			equipoPatronDTO.setDescripcionTecnica(equipoPatron.getDescripcionTecnica());
			
			listaEquiposPatronDTO.add(equipoPatronDTO);
		}

		return listaEquiposPatronDTO;
	}

	@Override
	public boolean eliminarVersionEquipoPatron(String codigoVersionAnterior) {

		boolean exito;
		
		// se desglosan del código la clase, subclase, plano y versión del equipo a buscar.	
		int codigoClase = Integer.parseInt(codigoVersionAnterior.substring(0, 2));
		int codigoSubclase = Integer.parseInt(codigoVersionAnterior.substring(2, 4));
		int plano = Integer.parseInt(codigoVersionAnterior.substring(13, 15));
		String version = codigoVersionAnterior.substring(5, 7);
		
		EquipoPatron e = new EquipoPatron();
				
		Ingenieria adminIngenieria = new Ingenieria();	
		
		// se busca el equipo patrón a eliminar
		e = adminIngenieria.buscarEquipoPatron(codigoClase, codigoSubclase, plano, version);
		
		exito = adminIngenieria.eliminarEquipoPatron(e.getIdEquipoPatron());
		
		return exito;
	}
	
	
	@Override
	public boolean eliminarVersionComponentePatron(String codigoVersionAnterior) {

		boolean exito;
		
		// se desglosa el código
		int codigoClase = Integer.parseInt(codigoVersionAnterior.substring(0, 2));
		int codigoSubclase = Integer.parseInt(codigoVersionAnterior.substring(2, 4));
		int codigoComponente = Integer.parseInt(codigoVersionAnterior.substring(8, 10));
		int codigoSubcomponente = Integer.parseInt(codigoVersionAnterior.substring(10, 12));
		
		String version = codigoVersionAnterior.substring(5, 7);
		
		int plano = Integer.parseInt(codigoVersionAnterior.substring(13, 15));
		
		ComponentePatron c = new ComponentePatron();
				
		Ingenieria adminIngenieria = new Ingenieria();	
		
		// se busca el componente patrón a eliminar
		c = adminIngenieria.buscarComponentePatron(codigoClase, codigoSubclase, version, codigoComponente, codigoSubcomponente, plano);
		
		exito = adminIngenieria.eliminarComponentePatron(c.getIdComponentePatron());
		
		return exito;
		
	}

	/**
	 * Método que busca en la base de datos las órdenes de fabricación que tenga el estado pasado como parámetro
	 */
	public List<OrdenFabricacionGeneralDTO> filtrarOrdenesFabricacion(String estado, Date fechaEstimadaInicio, Date fechaEstimadaFinalizacion, boolean pReservasYCompras)
	{
		D_OrdenFabricacionGeneral ordenFabricacionDominio = new D_OrdenFabricacionGeneral();
		List<OrdenFabricacionGeneral> ordenes;
		List<OrdenFabricacionGeneralDTO> ordenesDTO = new LinkedList<OrdenFabricacionGeneralDTO>();
		
		if(estado.equals("TODOS LOS ESTADOS"))
			estado = "";
		
		
		//se utiliza para formatear fechas
		final SimpleDateFormat formatoFecha = new SimpleDateFormat("yyyy-MM-dd");
		String fechaInicio = "";
		String fechaFinalizacion = "";
		
		if(fechaEstimadaInicio != null)
			fechaInicio = formatoFecha.format(fechaEstimadaInicio);
		
		if(fechaEstimadaFinalizacion != null)
			fechaFinalizacion = formatoFecha.format(fechaEstimadaFinalizacion);
		
		//buscamos las órdenes activas en la base de datos
		ordenes = ordenFabricacionDominio.filtrar(estado, fechaInicio, fechaFinalizacion, pReservasYCompras);
		
		//cargamos los objetos dto
		for(OrdenFabricacionGeneral orden : ordenes)
		{
			OrdenFabricacionGeneralDTO ordenDTO = new OrdenFabricacionGeneralDTO();
			Set<RenglonOrdenFabricacionGeneralDTO> renglonesOrdenFabricacionGeneralDTO = new HashSet<RenglonOrdenFabricacionGeneralDTO>();
			LinkedList<RenglonOrdenPedidoDTO> renglonesOrdenPedidoDTO = new LinkedList<RenglonOrdenPedidoDTO>();
			
			//seteamos los datos a la orden
			ordenDTO.setNroOrden(orden.getNroOrden());
			ordenDTO.setEstado(orden.getEstado());
			ordenDTO.setFechaPrevistaInicio(orden.getFechaPrevistaInicio());
			ordenDTO.setFechaPrevistaFinalizacion(orden.getFechaPrevistaFinalizacion());
			ordenDTO.setFechaGeneracion(orden.getFechaGeneracion());
			ordenDTO.setResponsable(orden.getEmpleado().getApellido() + ", " + orden.getEmpleado().getNombre());
			ordenDTO.setObservaciones(orden.getObservaciones());
			
			//creamos la orden de pedido y se la seteamos a la orden de fabricación
			OrdenPedidoDTO ordenPedido = new OrdenPedidoDTO();
			ordenPedido.setNroOrden(orden.getOrdenPedido().getNroOrden());
			ordenPedido.setFechaGeneracion(orden.getOrdenPedido().getFechaGeneracion());
			
			if(orden.getOrdenPedido().getCliente() != null) 
				ordenPedido.setNombreCliente(orden.getOrdenPedido().getCliente().getNombre());
			
			else
				ordenPedido.setNombreCliente("PLANIFICADA");
				
			ordenPedido.setFechaPrevistaEntrega(orden.getOrdenPedido().getFechaPrevistaEntrega());
			ordenPedido.setObservacion(orden.getOrdenPedido().getObservacion());
			
			for(RenglonOrdenPedido renglon : orden.getOrdenPedido().getRenglonOrdenPedidos()) {
			
				RenglonOrdenPedidoDTO renglonDTO = new RenglonOrdenPedidoDTO();
				
				renglonDTO.setId(renglon.getId().getIdRenglonOrdenPedido());
				renglonDTO.setNombre(renglon.getNombreParaCliente());
				renglonDTO.setCantidad(renglon.getCantidad());
				
				//si el renglón tiene cargado un equipo
				if(renglon.getEquipoPatron() != null)
				{
					//generamos el código del equipo
					EquipoPatronDTO equipoDTO = new EquipoPatronDTO();
					
					equipoDTO.setCodigoClase(renglon.getEquipoPatron().getSubclaseEquipoPatron().getId().getCodigoClaseEquipoPatron());
					equipoDTO.setCodigoSubclase(renglon.getEquipoPatron().getSubclaseEquipoPatron().getId().getCodigoSubclaseEquipoPatron());
					equipoDTO.setPlano(renglon.getEquipoPatron().getPlano());
					equipoDTO.setNroVersion(renglon.getEquipoPatron().getNroVersion());
					
					renglonDTO.setCodigo(Validaciones.rellenarCodigoEquipoPatron(equipoDTO));
					renglonDTO.setEquipoOComponente("EQUIPO");
					renglonDTO.setIdListaMateriales(renglon.getEquipoPatron().getListaDeMateriales().getIdListaMateriales());
					renglonDTO.setEstadoListaMateriales(renglon.getEquipoPatron().getListaDeMateriales().getEstado());
					renglonDTO.setCantidadDisponible(renglon.getEquipoPatron().getCantidadDisponible());
				}
				
				//si el renglón tiene cargado un componente
				else
				{
					//generamos el código del componente
					ComponentePatronDTO componenteDTO = new ComponentePatronDTO();
					
					componenteDTO.setCodigoClase(renglon.getComponentePatron().getSubclaseEquipoPatron().getId().getCodigoClaseEquipoPatron());
					componenteDTO.setCodigoSubclase(renglon.getComponentePatron().getSubclaseEquipoPatron().getId().getCodigoSubclaseEquipoPatron());
					componenteDTO.setCodigoComponente(renglon.getComponentePatron().getCodigoComponente());
					componenteDTO.setCodigoSubcomponente(renglon.getComponentePatron().getCodigoSubcomponente());
					componenteDTO.setPlano(renglon.getComponentePatron().getPlano());
					componenteDTO.setNroVersion(renglon.getComponentePatron().getNroVersion());
					
					renglonDTO.setCodigo(Validaciones.rellenarCodigoComponentePatron(componenteDTO));
					renglonDTO.setEquipoOComponente("COMPONENTE");
					renglonDTO.setIdListaMateriales(renglon.getComponentePatron().getListaDeMateriales().getIdListaMateriales());
					renglonDTO.setEstadoListaMateriales(renglon.getComponentePatron().getListaDeMateriales().getEstado());
					renglonDTO.setCantidadDisponible(renglon.getComponentePatron().getCantidadDisponible());
				}
				
				renglonesOrdenPedidoDTO.add(renglonDTO);
			}
			
			for(RenglonOrdenFabricacionGeneral renglonOrdenFabricacionGeneral : orden.getRenglonOrdenFabricacionGenerals()) {
				
				RenglonOrdenFabricacionGeneralDTO renglonOrdenFabricacionGeneralDTO = new RenglonOrdenFabricacionGeneralDTO();
				RenglonOrdenPedidoDTO renglonOrdenPedidoDTO = new RenglonOrdenPedidoDTO();
				
				renglonOrdenFabricacionGeneralDTO.setCantidadAProducir(renglonOrdenFabricacionGeneral.getCantidadAProducir());
				renglonOrdenFabricacionGeneralDTO.setFechaEstimadaFinalizacion(renglonOrdenFabricacionGeneral.getFechaEstimadaFinalizacion());
				renglonOrdenFabricacionGeneralDTO.setFechaEstimadaInicio(renglonOrdenFabricacionGeneral.getFechaEstimadaInicio());
				renglonOrdenFabricacionGeneralDTO.setNroRenglon(renglonOrdenFabricacionGeneral.getId().getIdRenglonOrdenFabricacion());
				
				renglonOrdenPedidoDTO.setCantidad(renglonOrdenFabricacionGeneral.getRenglonOrdenPedido().getCantidad());
				if (renglonOrdenFabricacionGeneral.getRenglonOrdenPedido().getEquipoPatron() != null) {
					//generamos el código del equipo
					EquipoPatronDTO equipoDTO = new EquipoPatronDTO();
					
					equipoDTO.setCodigoClase(renglonOrdenFabricacionGeneral.getRenglonOrdenPedido().getEquipoPatron().getSubclaseEquipoPatron().getId().getCodigoClaseEquipoPatron());
					equipoDTO.setCodigoSubclase(renglonOrdenFabricacionGeneral.getRenglonOrdenPedido().getEquipoPatron().getSubclaseEquipoPatron().getId().getCodigoSubclaseEquipoPatron());
					equipoDTO.setPlano(renglonOrdenFabricacionGeneral.getRenglonOrdenPedido().getEquipoPatron().getPlano());
					equipoDTO.setNroVersion(renglonOrdenFabricacionGeneral.getRenglonOrdenPedido().getEquipoPatron().getNroVersion());
					
					renglonOrdenPedidoDTO.setCodigo(Validaciones.rellenarCodigoEquipoPatron(equipoDTO));
					renglonOrdenPedidoDTO.setEquipoOComponente("EQUIPO");
					renglonOrdenPedidoDTO.setEstadoListaMateriales(renglonOrdenFabricacionGeneral.getRenglonOrdenPedido().getEquipoPatron().getListaDeMateriales().getEstado());
					renglonOrdenPedidoDTO.setCantidadDisponible(renglonOrdenFabricacionGeneral.getRenglonOrdenPedido().getEquipoPatron().getCantidadDisponible());
					renglonOrdenPedidoDTO.setIdListaMateriales(renglonOrdenFabricacionGeneral.getRenglonOrdenPedido().getEquipoPatron().getListaDeMateriales().getIdListaMateriales());
				}
				else {
					//generamos el código del componente
					ComponentePatronDTO componenteDTO = new ComponentePatronDTO();
					
					componenteDTO.setCodigoClase(renglonOrdenFabricacionGeneral.getRenglonOrdenPedido().getComponentePatron().getSubclaseEquipoPatron().getId().getCodigoClaseEquipoPatron());
					componenteDTO.setCodigoSubclase(renglonOrdenFabricacionGeneral.getRenglonOrdenPedido().getComponentePatron().getSubclaseEquipoPatron().getId().getCodigoSubclaseEquipoPatron());
					componenteDTO.setCodigoComponente(renglonOrdenFabricacionGeneral.getRenglonOrdenPedido().getComponentePatron().getCodigoComponente());
					componenteDTO.setCodigoSubcomponente(renglonOrdenFabricacionGeneral.getRenglonOrdenPedido().getComponentePatron().getCodigoSubcomponente());
					componenteDTO.setPlano(renglonOrdenFabricacionGeneral.getRenglonOrdenPedido().getComponentePatron().getPlano());
					componenteDTO.setNroVersion(renglonOrdenFabricacionGeneral.getRenglonOrdenPedido().getComponentePatron().getNroVersion());
					
					renglonOrdenPedidoDTO.setCodigo(Validaciones.rellenarCodigoComponentePatron(componenteDTO));
					renglonOrdenPedidoDTO.setEquipoOComponente("COMPONENTE");
					renglonOrdenPedidoDTO.setEstadoListaMateriales(renglonOrdenFabricacionGeneral.getRenglonOrdenPedido().getComponentePatron().getListaDeMateriales().getEstado());
					renglonOrdenPedidoDTO.setCantidadDisponible(renglonOrdenFabricacionGeneral.getRenglonOrdenPedido().getComponentePatron().getCantidadDisponible());
					renglonOrdenPedidoDTO.setIdListaMateriales(renglonOrdenFabricacionGeneral.getRenglonOrdenPedido().getComponentePatron().getListaDeMateriales().getIdListaMateriales());
				}
				
				renglonOrdenFabricacionGeneralDTO.setRenglonOrdenPedidoDTO(renglonOrdenPedidoDTO);
				
				renglonesOrdenFabricacionGeneralDTO.add(renglonOrdenFabricacionGeneralDTO);
			}
			
			//seteamos los renglones a la orden de pedido
			ordenPedido.setRenglonOrdenPedidosDTO(renglonesOrdenPedidoDTO);
			
			//seteamos la orden de pedido a la orden de fabricación
			ordenDTO.setOrdenPedidoDTO(ordenPedido);
			
			ordenDTO.setRenglonOrdenFabricacionGeneralsDTO(renglonesOrdenFabricacionGeneralDTO);
			
			ordenesDTO.add(ordenDTO);
		}
		
		return ordenesDTO;
	}
	
	/**
	 * Método que busca en la base de datos todos los renglones de una orden de fabricaicón particular.
	 */
	public Set<RenglonOrdenFabricacionGeneralDTO> buscarRenglonesOrdenFabricacion(int nroOrdenFabricacion)
	{
		D_OrdenFabricacionGeneral ordenFabricacionDominio = new D_OrdenFabricacionGeneral();
		Set<RenglonOrdenFabricacionGeneral> renglones;
		Set<RenglonOrdenFabricacionGeneralDTO> renglonesDTO = new HashSet<RenglonOrdenFabricacionGeneralDTO>();
		
		//buscamos los renglones de la orden de pedido en la base de datos
		renglones = ordenFabricacionDominio.buscarRenglones(nroOrdenFabricacion);
		
		for(RenglonOrdenFabricacionGeneral renglon : renglones)
		{
			RenglonOrdenFabricacionGeneralDTO renglonOrdenFabricacionDTO = new RenglonOrdenFabricacionGeneralDTO();
		
			//recuperamos el renglon de la orden de pedido
			RenglonOrdenPedido renglonOrdenPedido = renglon.getRenglonOrdenPedido();
			
			
			//ceamos un renglonOrdenPedidoDTO con los datos del renglon de la orden de pedido
			RenglonOrdenPedidoDTO renglonOrdenPedidoDTO = new RenglonOrdenPedidoDTO();	
			
			renglonOrdenPedidoDTO.setId(renglonOrdenPedido.getId().getIdRenglonOrdenPedido());
			renglonOrdenPedidoDTO.setNombre(renglonOrdenPedido.getNombreParaCliente());
			renglonOrdenPedidoDTO.setCantidad(renglonOrdenPedido.getCantidad());

			//si el renglón tiene cargado un equipo
			if(renglonOrdenPedido.getEquipoPatron() != null)
			{
				//generamos el código del equipo
				EquipoPatronDTO equipoDTO = new EquipoPatronDTO();
				
				equipoDTO.setCodigoClase(renglonOrdenPedido.getEquipoPatron().getSubclaseEquipoPatron().getId().getCodigoClaseEquipoPatron());
				equipoDTO.setCodigoSubclase(renglonOrdenPedido.getEquipoPatron().getSubclaseEquipoPatron().getId().getCodigoSubclaseEquipoPatron());
				equipoDTO.setPlano(renglonOrdenPedido.getEquipoPatron().getPlano());
				equipoDTO.setNroVersion(renglonOrdenPedido.getEquipoPatron().getNroVersion());
				
				renglonOrdenPedidoDTO.setCodigo(Validaciones.rellenarCodigoEquipoPatron(equipoDTO));
				renglonOrdenPedidoDTO.setEstadoListaMateriales(renglonOrdenPedido.getEquipoPatron().getListaDeMateriales().getEstado());
				renglonOrdenPedidoDTO.setCantidadDisponible(renglonOrdenPedido.getEquipoPatron().getCantidadDisponible());
			}

			//si el renglón tiene cargado un componente
			else
			{
				//generamos el código del componente
				ComponentePatronDTO componenteDTO = new ComponentePatronDTO();
				
				componenteDTO.setCodigoClase(renglonOrdenPedido.getComponentePatron().getSubclaseEquipoPatron().getId().getCodigoClaseEquipoPatron());
				componenteDTO.setCodigoSubclase(renglonOrdenPedido.getComponentePatron().getSubclaseEquipoPatron().getId().getCodigoSubclaseEquipoPatron());
				componenteDTO.setPlano(renglonOrdenPedido.getComponentePatron().getPlano());
				componenteDTO.setNroVersion(renglonOrdenPedido.getComponentePatron().getNroVersion());
				
				renglonOrdenPedidoDTO.setCodigo(Validaciones.rellenarCodigoComponentePatron(componenteDTO));
				renglonOrdenPedidoDTO.setEstadoListaMateriales(renglonOrdenPedido.getComponentePatron().getListaDeMateriales().getEstado());
				renglonOrdenPedidoDTO.setCantidadDisponible(renglonOrdenPedido.getComponentePatron().getCantidadDisponible());
			}
						
			//seteamos los demás datos al renglón de la orden de fabricación
			renglonOrdenFabricacionDTO.setNroRenglon(renglon.getId().getIdRenglonOrdenFabricacion());
			renglonOrdenFabricacionDTO.setNroOrdenFabricacion(renglon.getId().getIdOrdenFabricacionGeneral());
			renglonOrdenFabricacionDTO.setRenglonOrdenPedidoDTO(renglonOrdenPedidoDTO);
			renglonOrdenFabricacionDTO.setCantidadAProducir(renglon.getCantidadAProducir());
			renglonOrdenFabricacionDTO.setFechaEstimadaInicio(renglon.getFechaEstimadaInicio());
			renglonOrdenFabricacionDTO.setFechaEstimadaFinalizacion(renglon.getFechaEstimadaFinalizacion());			
			
			renglonesDTO.add(renglonOrdenFabricacionDTO);
		}
		
		return renglonesDTO;
	}
	
	
	/**
	 * Método que actualizará la cantidad de equipos patrón disponibles en inventario.
	 * @param cantidadARestar será la cantidad que hay que restar de inventario.
	 */
	public int actualizarCantidadEquipoPatron (int codigoClase, int codigoSubclase, int plano, String version, int cantidadARestar) {
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		EquipoPatron equipoPatron = adminIngenieria.buscarEquipoPatron(codigoClase, codigoSubclase, plano, version);
		
		equipoPatron.setCantidadDisponible(equipoPatron.getCantidadDisponible() - cantidadARestar);
		
		return adminIngenieria.actualizarCantidadEquipoPatron(equipoPatron);
	}
	
	
	/**
	 * Método que actualizará la cantidad de componentes patrón disponibles en inventario.
	 * @param cantidadARestar será la cantidad que hay que restar de inventario.
	 */
	public int actualizarCantidadComponentePatron (int codigoClase, int codigoSubclase, String version, int codigoComponente, int codigoSubcomponente, int plano, int cantidadARestar) {
		
		Ingenieria adminIngenieria = new Ingenieria();
		
		ComponentePatron componentePatron = adminIngenieria.buscarComponentePatron(codigoClase, codigoSubclase, version, codigoComponente, codigoSubcomponente, plano);
		
		componentePatron.setCantidadDisponible(componentePatron.getCantidadDisponible() - cantidadARestar);
		
		return adminIngenieria.actualizarCantidadComponentePatron(componentePatron);
	}
}
